Antes de mais nada veja o artigo anterior sobre o provedor do vRA no Terraform. Vou assumir que você sabe sobre o que estou falando e vou direto ao assunto. Vamos começar com um blueprint simples:

formatVersion: 1
inputs:
  ambiente:
    type: string
    title: Ambiente
    description: Selecione o ambiente para deploy
    #default: prod
    oneOf:
      - title: Produção
        const: prod
      - title: Desenvolvimento
        const: dev
  servico:
    type: string
    title: Serviço
    description: Selecione o tipo do servidor
    oneOf:
      - title: Application
        const: app
      - title: Database
        const: db
      - title: Web Server
        const: web
  so:
    type: string
    title: Sistema Operacional
    description: Selecione o sistema operacional
    oneOf:
      - title: Ubuntu 22.04
        const: Ubuntu 22.04
      - title: Ubuntu 22.10
        const: Ubuntu 22.10
  instancias:
    type: integer
    title: Instâncias
    description: Digite a quantidade de instâncias desejada
    maximum: 10
    minimum: 1
  discoadicional:
    type: array
    title: Discos adicionais
    description: Até 5 discos extra por instância
    minItems: 0
    maxItems: 5
    items:
      type: object
      properties:
        size:
          type: integer
          title: Tamanho do disco (GB)
          minimum: 1
          maximum: 500
        SCSIController:
          type: string
          title: SCSI Controller
          enum:
            - SCSI_Controller_0
            - SCSI_Controller_1
            - SCSI_Controller_2
            - SCSI_Controller_3
resources:
  VM:
    type: Cloud.vSphere.Machine
    properties:
      name: '${"CAV-" + (input.ambiente == "prod" ? "P" : "D") + "-" + to_upper(input.servico) + "-"}'
      image: ${input.so}
      flavor: Small
      servico: ${input.servico}
      ambiente: ${input.ambiente}
      constraints:
        - tag: ${'environment:' + (input.ambiente)}
        - tag: ${'service:' + (input.servico)}
      networks:
        - network: ${resource.rede.id}
          assignment: static
      attachedDisks: ${map_to_object(slice(resource.disco[*].id, length(input.discoadicional)*count.index, length(input.discoadicional)*(count.index+1)), "source")}
  rede:
    type: Cloud.vSphere.Network
    properties:
      networkType: existing
      constraints:
        - tag: ${'environment:' + (input.ambiente)}
        - tag: ${'service:' + (input.servico)}
  disco:
    type: Cloud.vSphere.Disk
    allocatePerInstance: true
    properties:
      capacityGb: '${(count.index < length(input.discoadicional) ? input.discoadicional[count.index].size : input.discoadicional[(count.index % length(input.discoadicional))].size)}'
      SCSIController: '${(count.index < length(input.discoadicional) ? input.discoadicional[count.index].SCSIController : input.discoadicional[(count.index % length(input.discoadicional))].SCSIController)}'
      count: ${length(input.discoadicional) * input.instancias}

Agora basta versionar o blueprint e publica-lo no catálogo do vRA. Garanta que o usuário utilizado pelo Terraform tenha acesso a este item de catálogo. Vamos criar o arquivo main.tf.

terraform {
  required_providers {
    vra = {
      source = "vmware/vra"
    }
  }
}

provider "vra" {
  url           = var.url
  refresh_token = var.refresh_token
  insecure      = var.insecure
}

data "vra_project" "this" {
  name = var.project_name
}

data "vra_catalog_item" "this" {
  name            = var.catalog_item_name
  expand_versions = true
}

resource "vra_deployment" "this" {
  catalog_item_id      = data.vra_catalog_item.this.id
  catalog_item_version = var.catalog_item_version
  project_id           = data.vra_project.this.id
  
  name        = var.deployment_name
  description = var.deployment_desc
  
  inputs = {
    ambiente       = var.input_ambiente
    servico        = var.input_servico
    so             = var.input_so
    instancias     = var.input_instancias
    discoadicional = jsonencode(var.input_discoadicional)
  }
  
  timeouts {
    create = var.timeout_create
  update = var.timeout_update
    delete = var.timeout_delete
  }
}

E por fim, vamos criar o arquivo variables.tf contendo todas as variáveis que são necessárias para conseguirmos fazer deploy do item de catálogo no vRA.

##### ARIA AUTOMATION (VRA) ENVIRONMENT #####
variable "url" {
  type    = string
  default = "https://seu-vra-lindao"
}

variable "refresh_token" {
  type    = string
  default = "xyz"
}

variable "insecure" {
  type    = bool
  default = "true"
}

##### PROJECT AND CATALOG ITEM #####

variable "project_name" {
  type    = string
  default = "seu-projeto"
}

variable "catalog_item_name" {
  type    = string
  default = "seu item de catálogo"
}

variable "catalog_item_version" {
  type    = string
  default = "versão do item de catálogo. Ex: 1.1"
}

##### DEPLYOMENT #####

variable "deployment_name" {
  type    = string
  default = "ubuntu terraform"
}

variable "deployment_desc" {
  type    = string
  default = "terraform test"
}

##### INPUTS #####

variable "input_ambiente" {
  type    = string
  default = "prod"
}

variable "input_servico" {
  type    = string
  default = "app"
}

variable "input_so" {
  type    = string
  default = "Ubuntu 22.04"
}

variable "input_instancias" {
  type    = number
  default = 1
}

variable "input_discoadicional" {
  type = list(object({
    size           = number
    SCSIController = string
  }))
  default = [
    {
      size           = 10
      SCSIController = "SCSI_Controller_1"
    }
  ]
}

##### TIMEOUT #####

variable "timeout_create" {
  type    = string
  default = "30m"
}

variable "timeout_update" {
  type    = string
  default = "30m"
}

variable "timeout_delete" {
  type    = string
  default = "30m"
}

Agora execute .\terraform.exe init e depois .\terraform.exe apply para fazermos o deploy do item de catálogo de fato.

E é isso aí, o item de catálogo foi criado com sucesso!

Até a próxima. Valeu!