Automate Nutanix Images With Ansible: A Full Guide

Aug 5, 2025 by ADMIN 51 views

Automating Nutanix Image Management with Ansible: A Comprehensive Guide

Hey guys! Ever felt like managing images in Nutanix is a bit of a hassle? You're not alone! That's where automation steps in to save the day. In this comprehensive guide, we're diving deep into automating Nutanix image management using Ansible. We'll explore how to use the ntnx_images_v2 module to handle the full lifecycle of image resources, from creation to deletion, with various source types like URLs, disks, and object stores. Plus, we'll look at how to integrate these images with VMs and categories. Let's get started!

Why Automate Nutanix Image Management?

Before we jump into the nitty-gritty, let's chat about why automating image management is crucial. Think about it: manually managing images can be time-consuming and error-prone. Automation, on the other hand, brings a bunch of benefits:

Time Savings: Automating repetitive tasks frees up your time for more strategic initiatives. No more spending hours clicking through menus!
Consistency: Automation ensures that your image deployments are consistent every single time. This reduces the risk of configuration drift and other pesky issues.
Reduced Errors: Let’s be honest, humans make mistakes. Automation minimizes human error, leading to more reliable and stable environments.
Scalability: As your infrastructure grows, automation makes it easier to manage a larger number of images without breaking a sweat.
Reproducibility: Infrastructure as Code (IaC) principles ensure that your image configurations are documented and reproducible, making disaster recovery and environment replication a breeze.

So, if you're not automating your Nutanix image management yet, you're missing out! Let's see how Ansible can help us out.

Understanding the `ntnx_images_v2` Module

The ntnx_images_v2 module is your go-to tool for managing images in Nutanix using Ansible. It allows you to perform all sorts of operations, including creating, retrieving, updating, and deleting images. This module supports various source types, giving you the flexibility to manage images from different locations. Let’s break down the key functionalities:

Creating Images: You can create images from various sources, such as URLs, existing disks, and object stores. This flexibility is crucial for different use cases, whether you're deploying from an ISO or cloning from an existing VM.
Retrieving Images: Need to find a specific image? The module allows you to retrieve images based on various criteria, such as name, UUID, or category. This makes it easy to keep track of your image inventory.
Updating Images: Sometimes, you need to tweak an image. The module lets you update image properties like name, description, and category, ensuring your images are always up-to-date.
Deleting Images: When an image is no longer needed, you can easily delete it using the module, keeping your environment clean and organized.

Now that we have a good grasp of the ntnx_images_v2 module, let's dive into some practical examples.

Setting the Stage: Prerequisites and Configuration

Before we jump into the Ansible playbook, let's make sure we have everything set up correctly. Here’s what you'll need:

Nutanix Cluster: You’ll need access to a Nutanix cluster. Make sure you have the necessary credentials to connect to it.
Ansible: Ensure Ansible is installed on your control machine. If not, you can install it using pip: pip install ansible.
Nutanix Ansible Modules: You'll need the Nutanix modules for Ansible. You can install them via pip: pip install nutanix-ansible-modules.
Credentials: You'll need the username, password, and Prism Central IP address to connect to your Nutanix environment. It’s best practice to store these credentials securely, such as in an Ansible Vault.

Once you have these prerequisites in place, you're ready to start crafting your Ansible playbook. Let’s move on to the playbook structure.

Crafting the Ansible Playbook: A Step-by-Step Guide

Now, let's get to the fun part: writing the Ansible playbook! We’ll walk through creating a playbook that demonstrates the full lifecycle of image management. This playbook will include tasks for creating images from different sources, retrieving images, updating them, and finally, deleting them.

Here’s the high-level structure of our playbook:

Create a VM with a disk: This step sets the stage by creating a virtual machine that we can use as a source for creating images.
Create an ISO image using a valid source URL: We’ll create an image from an ISO file hosted on a URL.
Create a disk image using a valid source URL: This involves creating an image from a disk file hosted on a URL.
Create a disk image from a VM disk source: Here, we’ll create an image by cloning from an existing VM's disk.
Create a disk image using Objects Lite Source: We'll create an image using a file stored in Nutanix Objects Lite.
Retrieve a specific image and filter image lists: We’ll demonstrate how to find images based on name and other criteria.
Update images by changing type, name, and category: This step shows how to modify image properties.
Delete an image: We’ll delete an image that’s no longer needed.
Delete the associated VM: Finally, we’ll clean up by deleting the VM we created in the first step.

Let’s dive into the details of each step!

1. Creating a VM with a Disk

First, we need a VM to play with. This VM will serve as a source for creating images later on. Here’s the Ansible task for creating a VM with a disk:

- name: Create a VM with a disk
  ntnx_vm:
    state: present
    name: SourceVM
    description: VM to be used as a source for image creation
    cluster: "{{ cluster_name }}"
    memory: 4GiB
    vcpus: 2
    disks:
      - data_source_kind: DISK
        disk_size_mib: 20480
        disk_type: SATA
    nics:
      - subnet: "{{ vm_subnet_uuid }}"
  register: vm_creation_result

In this task:

We're using the ntnx_vm module to create a VM.
We're setting the state to present, which means Ansible will create the VM if it doesn't exist.
We're defining the VM's name, description, memory, and vCPUs.
We're creating a 20GB disk (disk_size_mib: 20480) for the VM.
We're also attaching the VM to a subnet (vm_subnet_uuid).
The register keyword saves the result of the task in the vm_creation_result variable, which we can use later.

2. Creating an ISO Image Using a Valid Source URL

Next up, let's create an ISO image from a URL. This is super handy for deploying operating systems. Here’s the task:

- name: Create an ISO image from a URL
  ntnx_image_v2:
    state: present
    name: CentOS-7-x86_64-Everything-2009.iso
    source_type: ISO_IMAGE
    source_uri: "http://mirror.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-Everything-2009.iso"
    description: CentOS 7 ISO image
  register: iso_image_creation_result

Here’s what’s happening:

We're using the ntnx_image_v2 module to create an image.
We're specifying the state as present.
We're giving the image a name (CentOS-7-x86_64-Everything-2009.iso).
We're setting the source_type to ISO_IMAGE.
We're providing the URL to the ISO file using source_uri.
We're adding a description for clarity.
The register keyword saves the result in iso_image_creation_result.

3. Creating a Disk Image Using a Valid Source URL

Now, let’s create a disk image from a URL. This is useful for deploying pre-configured virtual disks. Check out the task:

- name: Create a disk image from a URL
  ntnx_image_v2:
    state: present
    name: CirrOS-0.5.2-x86_64-disk.img
    source_type: DISK_IMAGE
    source_uri: "https://download.cirros-cloud.net/0.5.2/cirros-0.5.2-x86_64-disk.img"
    description: CirrOS disk image
  register: disk_image_creation_result

This task is quite similar to the previous one:

We're using the ntnx_image_v2 module.
We're setting the state to present.
We're naming the image (CirrOS-0.5.2-x86_64-disk.img).
We're setting the source_type to DISK_IMAGE.
We're providing the URL to the disk image using source_uri.
We're adding a description.
The register keyword saves the result in disk_image_creation_result.

4. Creating a Disk Image from a VM Disk Source

Next, we'll create an image from the disk of the VM we created earlier. This is great for cloning VMs. Here’s the task:

- name: Create a disk image from VM disk source
  ntnx_image_v2:
    state: present
    name: SourceVM-Disk-Image
    source_type: DISK_IMAGE
    vm_disk_id: "{{ vm_creation_result.entities[0].disks[0].uuid }}"
    description: Disk image from SourceVM
  register: vm_disk_image_creation_result

Here’s what’s going on:

We're using the ntnx_image_v2 module.
We're setting the state to present.
We're naming the image (SourceVM-Disk-Image).
We're setting the source_type to DISK_IMAGE.
We're using vm_disk_id to specify the UUID of the VM's disk. We're getting this UUID from the vm_creation_result variable, which we registered when creating the VM.
We're adding a description.
The register keyword saves the result in vm_disk_image_creation_result.

5. Creating a Disk Image Using Objects Lite Source

If you're using Nutanix Objects Lite, you can create images from files stored there. Here’s how:

- name: Create a disk image using Objects Lite Source
  ntnx_image_v2:
    state: present
    name: ObjectsLiteImage.qcow2
    source_type: DISK_IMAGE
    object_store_name: ObjectsLite
    source_path: /path/to/ObjectsLiteImage.qcow2
    description: Disk image from Objects Lite
  register: objects_lite_image_creation_result

In this task:

We're using the ntnx_image_v2 module.
We're setting the state to present.
We're naming the image (ObjectsLiteImage.qcow2).
We're setting the source_type to DISK_IMAGE.
We're specifying the object_store_name as ObjectsLite (replace with your actual object store name).
We're providing the path to the image in the object store using source_path.
We're adding a description.
The register keyword saves the result in objects_lite_image_creation_result.

6. Retrieving a Specific Image and Filtering Image Lists

Now, let’s see how to retrieve images. We’ll retrieve a specific image by name and also filter a list of images. Here’s the task:

- name: Retrieve a specific image by name
  ntnx_image_v2:
    state: present
    name: CentOS-7-x86_64-Everything-2009.iso
  register: retrieved_image

- name: Print retrieved image details
  debug:
    var: retrieved_image.entities[0]

- name: Filter image lists by category
  ntnx_image_v2:
    state: present
    categories: 
      Environment: Development
  register: filtered_images

- name: Print filtered images
  debug:
    var: filtered_images

In this task:

We're using the ntnx_image_v2 module to retrieve an image by name. We set the state to present and specify the name.
We're using the debug module to print the details of the retrieved image.
We're filtering images by category using the categories parameter. This is super useful for organizing your images.
We're printing the filtered images using the debug module.

7. Updating Images by Changing Type, Name, and Category

Sometimes, you need to update image properties. Here’s how to do it:

- name: Update image properties
  ntnx_image_v2:
    state: present
    uuid: "{{ iso_image_creation_result.entities[0].uuid }}"
    name: Updated-CentOS-7-x86_64-Everything-2009.iso
    description: Updated CentOS 7 ISO image
    categories:
      Environment: Production
  register: updated_image_result

In this task:

We're using the ntnx_image_v2 module.
We're setting the state to present.
We're specifying the uuid of the image we want to update. We're getting this UUID from the iso_image_creation_result variable, which we registered when creating the ISO image.
We're changing the name and description of the image.
We're updating the categories to reflect a new environment (Production).
The register keyword saves the result in updated_image_result.

8. Deleting an Image

When an image is no longer needed, you can delete it. Here’s the task:

- name: Delete an image
  ntnx_image_v2:
    state: absent
    uuid: "{{ iso_image_creation_result.entities[0].uuid }}"

In this task:

We're using the ntnx_image_v2 module.
We're setting the state to absent, which tells Ansible to delete the image.
We're specifying the uuid of the image we want to delete. We're getting this UUID from the iso_image_creation_result variable.

9. Deleting the Associated VM

Finally, let's clean up by deleting the VM we created at the beginning. Here’s the task:

- name: Delete the associated VM
  ntnx_vm:
    state: absent
    uuid: "{{ vm_creation_result.entities[0].uuid }}"

In this task:

We're using the ntnx_vm module.
We're setting the state to absent to delete the VM.
We're specifying the uuid of the VM we want to delete. We're getting this UUID from the vm_creation_result variable.

Putting It All Together: The Complete Playbook

Now that we’ve walked through each step, let’s put it all together into a complete Ansible playbook. Here’s what the full playbook looks like:

--- 
- hosts: localhost
  connection: local
  gather_facts: false
  vars:
    cluster_name: "YourClusterName" # Replace with your cluster name
    vm_subnet_uuid: "YourSubnetUUID" # Replace with your subnet UUID

  tasks:
    - name: Create a VM with a disk
      ntnx_vm:
        state: present
        name: SourceVM
        description: VM to be used as a source for image creation
        cluster: "{{ cluster_name }}"
        memory: 4GiB
        vcpus: 2
        disks:
          - data_source_kind: DISK
            disk_size_mib: 20480
            disk_type: SATA
        nics:
          - subnet: "{{ vm_subnet_uuid }}"
      register: vm_creation_result

    - name: Create an ISO image from a URL
      ntnx_image_v2:
        state: present
        name: CentOS-7-x86_64-Everything-2009.iso
        source_type: ISO_IMAGE
        source_uri: "http://mirror.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-Everything-2009.iso"
        description: CentOS 7 ISO image
      register: iso_image_creation_result

    - name: Create a disk image from a URL
      ntnx_image_v2:
        state: present
        name: CirrOS-0.5.2-x86_64-disk.img
        source_type: DISK_IMAGE
        source_uri: "https://download.cirros-cloud.net/0.5.2/cirros-0.5.2-x86_64-disk.img"
        description: CirrOS disk image
      register: disk_image_creation_result

    - name: Create a disk image from VM disk source
      ntnx_image_v2:
        state: present
        name: SourceVM-Disk-Image
        source_type: DISK_IMAGE
        vm_disk_id: "{{ vm_creation_result.entities[0].disks[0].uuid }}"
        description: Disk image from SourceVM
      register: vm_disk_image_creation_result

    - name: Create a disk image using Objects Lite Source
      ntnx_image_v2:
        state: present
        name: ObjectsLiteImage.qcow2
        source_type: DISK_IMAGE
        object_store_name: ObjectsLite
        source_path: /path/to/ObjectsLiteImage.qcow2
        description: Disk image from Objects Lite
      register: objects_lite_image_creation_result

    - name: Retrieve a specific image by name
      ntnx_image_v2:
        state: present
        name: CentOS-7-x86_64-Everything-2009.iso
      register: retrieved_image

    - name: Print retrieved image details
      debug:
        var: retrieved_image.entities[0]

    - name: Filter image lists by category
      ntnx_image_v2:
        state: present
        categories: 
          Environment: Development
      register: filtered_images

    - name: Print filtered images
      debug:
        var: filtered_images

    - name: Update image properties
      ntnx_image_v2:
        state: present
        uuid: "{{ iso_image_creation_result.entities[0].uuid }}"
        name: Updated-CentOS-7-x86_64-Everything-2009.iso
        description: Updated CentOS 7 ISO image
        categories:
          Environment: Production
      register: updated_image_result

    - name: Delete an image
      ntnx_image_v2:
        state: absent
        uuid: "{{ iso_image_creation_result.entities[0].uuid }}"

    - name: Delete the associated VM
      ntnx_vm:
        state: absent
        uuid: "{{ vm_creation_result.entities[0].uuid }}"

To run this playbook, save it to a file (e.g., image_management.yml) and run the following command:

ansible-playbook image_management.yml -i "localhost," -k -u your_username

Make sure to replace YourClusterName and YourSubnetUUID with your actual cluster name and subnet UUID. Also, replace your_username with your Prism Central username.

Best Practices and Tips

Before we wrap up, let’s cover some best practices and tips for managing Nutanix images with Ansible:

Use Variables: Use variables for values that might change, such as cluster names, subnet UUIDs, and image names. This makes your playbooks more reusable and easier to maintain.
Store Credentials Securely: Never hardcode credentials in your playbooks. Use Ansible Vault or other secrets management tools to store sensitive information.
Idempotency: Ensure your tasks are idempotent. This means running the same task multiple times should have the same result. The ntnx_images_v2 and ntnx_vm modules are designed to be idempotent, but it’s always a good idea to test.
Error Handling: Implement error handling in your playbooks. Use the ignore_errors parameter or the rescue block to handle potential failures gracefully.
Testing: Always test your playbooks in a non-production environment before deploying them to production. This helps you catch any issues early on.
Documentation: Document your playbooks. Add comments to explain what each task does. This makes it easier for others (and your future self) to understand and maintain your playbooks.

Conclusion

Alright, guys, we’ve covered a ton in this guide! We’ve explored how to automate Nutanix image management using Ansible, from creating images from various sources to retrieving, updating, and deleting them. We’ve also looked at how to integrate images with VMs and categories. By leveraging the ntnx_images_v2 module, you can streamline your image management workflows and free up time for more strategic tasks.

Automation is the key to managing modern infrastructure efficiently. By embracing tools like Ansible, you can ensure consistency, reduce errors, and scale your Nutanix environment with ease. So, go ahead and start automating your Nutanix image management today! You'll be glad you did.

Why Automate Nutanix Image Management?

Understanding the ntnx_images_v2 Module

Setting the Stage: Prerequisites and Configuration

Crafting the Ansible Playbook: A Step-by-Step Guide

1. Creating a VM with a Disk

2. Creating an ISO Image Using a Valid Source URL

3. Creating a Disk Image Using a Valid Source URL

4. Creating a Disk Image from a VM Disk Source

5. Creating a Disk Image Using Objects Lite Source

6. Retrieving a Specific Image and Filtering Image Lists

7. Updating Images by Changing Type, Name, and Category

8. Deleting an Image

9. Deleting the Associated VM

Putting It All Together: The Complete Playbook

Best Practices and Tips

Conclusion

Understanding the `ntnx_images_v2` Module