Neste artigo veremos em que consiste o Terraform e também lançaremos gradativamente nossa própria infraestrutura — prepararemos três VMs para finalidades diferentes: proxy, armazenamento de arquivos e CMS.
Sobre tudo detalhadamente e em três etapas:
1. Terraform – descrição, vantagens e componentes
Terraform é uma ferramenta IaC (Infraestrutura como Código) para construir e gerenciar infraestrutura virtual usando código.
Observamos diversas vantagens em trabalhar com a ferramenta:
-
Velocidade de implantação de novos locatários (ambientes virtuais personalizados). Normalmente, quanto mais novos clientes houver, mais “cliques” a equipe de suporte técnico precisará fazer para publicar novos recursos. Com o Terraform, os usuários podem alterar as configurações da máquina virtual (por exemplo, desligar automaticamente o sistema operacional e aumentar a partição do disco virtual) sem precisar de suporte técnico ou desligar a própria máquina.
-
Verificação instantânea do plano de ativação novo Tenant. Utilizando a descrição do código da infraestrutura, podemos verificar imediatamente o que será adicionado e em que ordem, bem como em que estado final estará esta ou aquela máquina virtual ou rede virtual com conexões a máquinas virtuais.
-
Capacidade de descrever as plataformas de nuvem mais populares. Você pode usar a ferramenta desde Amazon e Google Cloud, até plataformas privadas baseadas em VMware vCloud Director, oferecendo serviços em soluções IaaS, SaaS e PaaS.
-
Gerencie vários provedores de nuvem e distribuir a infraestrutura entre eles para melhorar a tolerância a falhas, usando uma configuração única para criar, diagnosticar e gerenciar recursos de nuvem.
-
Uso conveniente para criar stands de demonstração para teste e depuração de software. Você pode criar e transferir suportes para o departamento de testes, testar software em diferentes ambientes em paralelo e alterar e excluir recursos instantaneamente criando apenas um plano de criação de recursos
Terraform "Terrário"
Falamos brevemente sobre as vantagens da ferramenta, agora vamos decompô-la em seus componentes
Provedores.
No Terraform, quase qualquer tipo de infraestrutura pode ser representada como um recurso. A conexão entre os recursos e a plataforma API é fornecida por módulos provedores, que permitem criar recursos dentro de uma plataforma específica, por exemplo, Azure ou VMware vCloud Director.
Como parte do projeto, você pode interagir com diferentes fornecedores em diferentes plataformas.
Recursos (descrição do recurso).
A descrição dos recursos permite gerenciar componentes da plataforma, como máquinas virtuais ou redes.
Você mesmo pode criar uma descrição de recurso para o provedor VMware vCloud Director e usar essa descrição para criar recursos com qualquer provedor de hospedagem que use o vCloud Director. Você só precisa alterar os parâmetros de autenticação e de conexão de rede para o provedor de hospedagem necessário
Provisionadores.
Este componente permite realizar operações de instalação inicial e manutenção do sistema operacional após a criação de máquinas virtuais. Depois de criar um recurso de máquina virtual, você poderá usar provisionadores para configurar e conectar via SSH, atualizar o sistema operacional e baixar e executar um script.
Variáveis de entrada e saída.
Variáveis de entrada - variáveis de entrada para qualquer tipo de bloco.
Variáveis de saída permitem salvar valores após a criação de recursos e podem ser usadas como variáveis de entrada em outros módulos, por exemplo no bloco Provisionadores.
Estados.
Os arquivos de estados armazenam informações sobre a configuração dos recursos da plataforma do provedor. Quando a plataforma é criada pela primeira vez não há informações sobre os recursos e antes de qualquer operação o Terraform atualiza o estado com a infraestrutura real dos recursos já descritos.
O principal objetivo dos estados é salvar vários objetos de recursos já criados para comparar a configuração dos recursos e objetos adicionados, a fim de evitar criações repetidas e alterações na plataforma.
Por padrão, as informações de estado são armazenadas no arquivo terraform.tfstate local, mas se necessário, é possível usar o armazenamento remoto para trabalho em equipe.
Você também pode importar recursos atuais da plataforma para o estado para interagir ainda mais com outros recursos que, por sua vez, foram criados sem a ajuda do Terraform.
2. Criação de infraestrutura
Os componentes foram resolvidos, agora utilizando o Terraform iremos criar gradativamente uma infraestrutura com três máquinas virtuais. O primeiro com servidor proxy nginx instalado, o segundo com armazenamento de arquivos baseado em Nextcloud e o terceiro com CMS Bitrix.
Vamos escrever o código e executá-lo usando nosso exemplo . Nossos usuários recebem uma conta com direitos de Administrador da Organização. Se você usar uma conta com os mesmos direitos em outra nuvem VMware, poderá reproduzir o código de nossos exemplos. Ir!
Primeiro, vamos criar um diretório para nosso novo projeto no qual serão colocados os arquivos que descrevem a infraestrutura.
mkdir project01
A seguir, descrevemos os componentes da infraestrutura. O Terraform cria relacionamentos e processa arquivos com base na descrição dos arquivos. Os próprios arquivos podem ser nomeados com base na finalidade dos blocos descritos, por exemplo, network.tf - descreve os parâmetros de rede para a infraestrutura.
Para descrever os componentes da nossa infraestrutura, criamos os seguintes arquivos:
Lista de arquivos.
main.tf - descrição dos parâmetros do ambiente virtual - máquinas virtuais, containers virtuais;
network.tf - descrição dos parâmetros da rede virtual e regras de NAT e Firewall;
variáveis.tf - lista de variáveis que usamos;
vcd.tfvars - valores de variáveis de projeto para o módulo VMware vCloud Director.
A linguagem de configuração no Terraform é declarativa e a ordem dos blocos não importa, exceto para os blocos provisionadores, pois neste bloco descrevemos os comandos a serem executados na preparação da infraestrutura e eles serão executados na ordem.
Estrutura de bloco.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Para descrever os blocos, utiliza-se sua própria linguagem de programação HCL (HashiCorp Configuration Language), sendo possível descrever a infraestrutura utilizando JSON. Você pode aprender mais sobre a sintaxe .
Configuração de variáveis de ambiente, variáveis.tf e vcd.tfvars
Primeiro, vamos criar dois arquivos que descrevem a lista de todas as variáveis utilizadas e seus valores para o módulo VMware vCloud Director. Primeiro, vamos criar o arquivo variáveis.tf.
Conteúdo do arquivo variáveis.tf.
variable "vcd_org_user" {
description = "vCD Tenant User"
}
variable "vcd_org_password" {
description = "vCD Tenant Password"
}
variable "vcd_org" {
description = "vCD Tenant Org"
}
variable "vcd_org_vdc" {
description = "vCD Tenant VDC"
}
variable "vcd_org_url" {
description = "vCD Tenant URL"
}
variable "vcd_org_max_retry_timeout" {
default = "60"
}
variable "vcd_org_allow_unverified_ssl" {
default = "true"
}
variable "vcd_org_edge_name" {
description = "vCD edge name"
}
variable "vcd_org_catalog" {
description = "vCD public catalog"
}
variable "vcd_template_os_centos7" {
description = "OS CentOS 7"
default = "CentOS7"
}
variable "vcd_org_ssd_sp" {
description = "Storage Policies"
default = "Gold Storage Policy"
}
variable "vcd_org_hdd_sp" {
description = "Storage Policies"
default = "Bronze Storage Policy"
}
variable "vcd_edge_local_subnet" {
description = "Organization Network Subnet"
}
variable "vcd_edge_external_ip" {
description = "External public IP"
}
variable "vcd_edge_local_ip_nginx" {}
variable "vcd_edge_local_ip_bitrix" {}
variable "vcd_edge_local_ip_nextcloud" {}
variable "vcd_edge_external_network" {}
Valores variáveis que recebemos do provedor.
-
vcd_org_user — nome de usuário com direitos de administrador da organização,
-
vcd_org_password — senha do usuário,
-
vcd_org — nome da organização,
-
vcd_org_vdc — nome do data center virtual,
-
vcd_org_url - URL da API,
-
vcd_org_edge_name — nome do roteador virtual,
-
vcd_org_catalog — nome do diretório com modelos de máquina virtual,
-
vcd_edge_external_ip — endereço IP público,
-
vcd_edge_external_network — nome da rede externa,
-
vcd_org_hdd_sp — nome da política de armazenamento do HDD,
-
vcd_org_ssd_sp — nome da política de armazenamento SSD.
E insira nossas variáveis:
-
vcd_edge_local_ip_nginx — Endereço IP da máquina virtual com NGINX,
-
vcd_edge_local_ip_bitrix - endereço IP da máquina virtual com 1C: Bitrix,
-
vcd_edge_local_ip_nextcloud — Endereço IP da máquina virtual com Nextcloud.
Com o segundo arquivo criamos e especificamos variáveis para o módulo VMware vCloud Director no arquivo vcd.tfvars: Lembremos que em nosso exemplo usamos , se você trabalha com outro provedor, verifique os valores com ele.
Conteúdo do arquivo vcd.tfvars.
vcd_org_url = "https://vcloud.mclouds.ru/api"
vcd_org_user = "orgadmin"
vcd_org_password = "*"
vcd = "org"
vcd_org_vdc = "orgvdc"
vcd_org_maxretry_timeout = 60
vcd_org_allow_unverified_ssl = true
vcd_org_catalog = "Templates"
vcd_templateos_centos7 = "CentOS7"
vcd_org_ssd_sp = "Gold Storage Policy"
vcd_org_hdd_sp = "Bronze Storage Policy"
vcd_org_edge_name = "MCLOUDS-EDGE"
vcd_edge_external_ip = "185.17.66.1"
vcd_edge_local_subnet = "192.168.110.0/24"
vcd_edge_local_ip_nginx = "192.168.110.1"
vcd_edge_local_ip_bitrix = "192.168.110.10"
vcd_edge_local_ip_nextcloud = "192.168.110.11"
vcd_edge_external_network = "NET-185-17-66-0"
Configuração de rede, network.tf.
As variáveis de ambiente estão definidas, agora vamos configurar o esquema de conexão da máquina virtual - vamos atribuir um endereço IP privado para cada máquina virtual e usar o Destination NAT para “encaminhar” as portas para a rede externa. Para limitar o acesso às portas de gerenciamento, definiremos o acesso apenas para o nosso endereço IP.
Diagrama de rede para a plataforma Terraform sendo criada
Criamos uma rede organizacional virtual com o nome net_lan01, o gateway padrão: 192.168.110.254, e também com o espaço de endereço: 192.168.110.0/24.
Descrevemos uma rede virtual.
resource "vcd_network_routed" "net" {
name = "net_lan01"
edge_gateway = var.vcd_org_edge_name
gateway = "192.168.110.254"
dns1 = "1.1.1.1"
dns2 = "8.8.8.8"
static_ip_pool {
start_address = "192.168.110.1"
end_address = "192.168.110.253"
}
}
Vamos criar regras de firewall que permitam que máquinas virtuais acessem a Internet. Dentro deste bloco, todos os recursos virtuais na nuvem terão acesso à Internet:
Descrevemos as regras para acesso de VMs à Internet.
resource "vcd_nsxv_firewall_rule" "fw_internet_access" {
edge_gateway = var.vcdorgedgename
name = "Internet Access"
source {
gateway_interfaces = ["internal"]
}
destination {
gateway_interfaces = ["external"]
}
service {
protocol = "any"
}
depends_on = [vcdnetworkrouted.net]
}
Tendo estabelecida a dependência que após processar o bloco vcdnetworkrouted.net, procedemos à configuração do bloco vcdnsxvfirewallrule, usando depende de. Usamos esta opção porque algumas dependências podem ser reconhecidas implicitamente na configuração.
A seguir criaremos regras que permitem o acesso às portas da rede externa e indicaremos nosso endereço IP para conexão via SSH aos servidores. Qualquer usuário da Internet tem acesso às portas 80 e 443 do servidor web, e um usuário com endereço IP 90.1.15.1 tem acesso às portas SSH dos servidores virtuais.
Permitir acesso às portas da rede externa.
resource "vcd_nsxv_firewall_rule" "fwnatports" {
edge_gateway = var.vcd_org_edge_name
name = "HTTPs Access"
source {
gateway_interfaces = ["external"]
}
destination {
gateway_interfaces = ["internal"]
}
service {
protocol = "tcp"
port = "80"
}
service {
protocol = "tcp"
port = "443"
}
depends_on = [vcd_network_routed.net]
}
resource "vcd_nsxv_firewall_rule" "fw_nat_admin_ports" {
edge_gateway = var.vcd_org_edge_name
name = "Admin Access"
source {
ip_addresses = [ "90.1.15.1" ]
}
destination {
gateway_interfaces = ["internal"]
}
service {
protocol = "tcp"
port = "58301"
}
service {
protocol = "tcp"
port = "58302"
}
service {
protocol = "tcp"
port = "58303"
}
depends_on = [vcd_network_routed.net]
}
Criamos regras Source NAT para acessar a Internet a partir de uma rede local na nuvem:
Descrevemos as regras do Source NAT.
resource "vcd_nsxv_snat" "snat_local" {
edge_gateway = var.vcd_org_edge_name
network_type = "ext"
network_name = var.vcdedgeexternalnetwork
original_address = var.vcd_edge_local_subnet
translated_address = var.vcd_edge_external_ip
depends_on = [vcd_network_routed.net]
}
E para completar a configuração do bloco de rede, adicionamos regras de Destination NAT para acesso aos serviços da rede externa:
Adicionando regras NAT de destino.
resource "vcd_nsxv_dnat" "dnat_tcp_nginx_https" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
description = "NGINX HTTPs"
original_address = var.vcd_edge_external_ip
original_port = 443
translated_address = var.vcd_edge_local_ip_nginx
translated_port = 443
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
resource "vcd_nsxv_dnat" "dnat_tcp_nginx_http" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
description = "NGINX HTTP"
original_address = var.vcd_edge_external_ip
original_port = 80
translated_address = var.vcd_edge_local_ip_nginx
translated_port = 80
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adicione uma regra NAT para tradução de porta ao servidor SSH no Nginx.
resource "vcd_nsxv_dnat" "dnat_tcp-nginx_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
description = "SSH NGINX"
original_address = var.vcd_edge_external_ip
original_port = 58301
translated_address = var.vcd_edge_local_ip_nginx
translated_port = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adicione uma regra NAT para tradução de porta ao servidor SSH com 1C-Bitrix.
resource "vcd_nsxv_dnat" "dnat_tcp_bitrix_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
description = "SSH Bitrix"
original_address = var.vcd_edge_external_ip
original_port = 58302
translated_address = var.vcd_edge_local_ip_bitrix
translated_port = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adicione uma regra NAT para tradução de porta ao servidor SSH com Nextcloud.
resource "vcd_nsxv_dnat" "dnat_tcp_nextcloud_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
description = "SSH Nextcloud"
original_address = var.vcd_edge_external_ip
original_port = 58303 translated_address = var.vcd_edge_local_ip_nextcloud
translated_port = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Configuração do ambiente virtual Main.tf
Conforme planejamos no início do artigo, criaremos três máquinas virtuais. Serão preparados através da “Personalização do Convidado”. Definiremos os parâmetros de rede de acordo com as configurações especificadas e a senha do usuário será gerada automaticamente.
Vamos descrever o vApp no qual as máquinas virtuais estarão localizadas e sua configuração.
Configuração de máquina virtual
Vamos criar um contêiner vApp. Para que possamos conectar imediatamente o vApp e a VM à rede virtual, também adicionamos o parâmetro depende_on:
Crie um contêiner
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Vamos criar uma máquina virtual com uma descrição
resource "vcd_vapp_vm" "nginx" {
vapp_name = vcd_vapp.vapp.name
name = "nginx"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memory = 8192
cpus = 1
cpu_cores = 1
network {
type = "org"
name = vcd_network_routed.net.name
is_primary = true
adapter_type = "VMXNET3"
ip_allocation_mode = "MANUAL"
ip = var.vcd_edge_local_ip_nginx
}
override_template_disk {
bus_type = "paravirtual"
size_in_mb = "32768"
bus_number = 0
unit_number = 0
storage_profile = var.vcd_org_ssd_sp
}
}
Principais parâmetros na descrição da VM:
-
nome – nome da máquina virtual,
-
vappname – nome do vApp ao qual adicionar uma nova VM,
-
catalogname / templatename - nome do catálogo e nome do modelo da máquina virtual,
-
storageprofile – política de armazenamento padrão.
Parâmetros do bloco de rede:
-
type — tipo de rede conectada,
-
nome – a qual rede virtual conectar a VM,
-
isprimary - adaptador de rede primário,
-
ipallocation_mode — modo de alocação de endereço MANUAL / DHCP / POOL,
-
ip — Endereço IP da máquina virtual, iremos especificá-lo manualmente.
bloco override_template_disk:
-
sizeinmb — tamanho do disco de inicialização da máquina virtual
-
storage_profile — política de armazenamento para o disco
Vamos criar uma segunda VM com uma descrição do armazenamento de arquivos Nextcloud
resource "vcd_vapp_vm" "nextcloud" {
vapp_name = vcd_vapp.vapp.name
name = "nextcloud"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memory = 8192
cpus = 1
cpu_cores = 1
network {
type = "org"
name = vcd_network_routed.net.name
is_primary = true
adapter_type = "VMXNET3"
ip_allocation_mode = "MANUAL"
ip = var.vcd_edge_local_ip_nextcloud
}
override_template_disk {
bus_type = "paravirtual"
size_in_mb = "32768"
bus_number = 0
unit_number = 0
storage_profile = var.vcd_org_ssd_sp
}
}
resource "vcd_vm_internal_disk" "disk1" {
vapp_name = vcd_vapp.vapp.name
vm_name = "nextcloud"
bus_type = "paravirtual"
size_in_mb = "102400"
bus_number = 0
unit_number = 1
storage_profile = var.vcd_org_hdd_sp
allow_vm_reboot = true
depends_on = [ vcd_vapp_vm.nextcloud ]
}
Na seção vcdvminternal_disk descreveremos um novo disco virtual que está conectado à máquina virtual.
Explicações para o bloco vcdvminternaldisk:
-
bustype - tipo de controlador de disco
-
sizeinmb — tamanho do disco
-
busnumber / unitnumber - local de conexão no adaptador
-
storage_profile — política de armazenamento para o disco
Vamos descrever a VM mais recente no Bitrix
resource "vcd_vapp_vm" "bitrix" {
vapp_name = vcd_vapp.vapp.name
name = "bitrix"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memory = 8192
cpus = 1
cpu_cores = 1
network {
type = "org"
name = vcd_network_routed.net.name
is_primary = true
adapter_type = "VMXNET3"
ip_allocation_mode = "MANUAL"
ip = var.vcd_edge_local_ip_bitrix
}
override_template_disk {
bus_type = "paravirtual"
size_in_mb = "81920"
bus_number = 0
unit_number = 0
storage_profile = var.vcd_org_ssd_sp
}
}
Atualizando o sistema operacional e instalando scripts adicionais
A rede está preparada, as máquinas virtuais são descritas. Antes de importar nossa infraestrutura, podemos realizar o provisionamento inicial antecipadamente usando blocos de provisionador e sem usar Ansible.
Vejamos como atualizar o sistema operacional e executar o script de instalação do CMS Bitrix usando o bloco provisionador.
Primeiro, vamos instalar os pacotes de atualização do CentOS.
resource "null_resource" "nginx_update_install" {
provisioner "remote-exec" {
connection {
type = "ssh"
user = "root"
password = vcd_vapp_vm.nginx.customization[0].admin_password
host = var.vcd_edge_external_ip
port = "58301"
timeout = "30s"
}
inline = [
"yum -y update && yum -y upgrade",
"yum -y install wget nano epel-release net-tools unzip zip" ]
}
}
}
Designação de componentes:
-
provisionador “remote-exec” - conecta o bloco de provisionamento remoto
-
No bloco de conexão descrevemos o tipo e os parâmetros da conexão:
-
tipo — protocolo, no nosso caso SSH;
-
usuário — nome de usuário;
-
senha – senha do usuário. No nosso caso, apontamos para o parâmetro vcdvappvm.nginx.customization[0].admin_password, que armazena a senha gerada para o usuário do sistema.
-
host — endereço IP externo para conexão;
-
port — porta para conexão, que foi previamente especificada nas configurações do DNAT;
-
inline - lista a lista de comandos que serão inseridos. Os comandos serão inseridos na ordem indicada nesta seção.
Como exemplo, vamos executar adicionalmente o script de instalação do 1C-Bitrix. A saída do resultado da execução do script estará disponível enquanto o plano estiver em execução. Para instalar o script, primeiro descrevemos o bloco:
Vamos descrever a instalação do 1C-Bitrix.
provisioner "file" {
source = "prepare.sh"
destination = "/tmp/prepare.sh"
connection {
type = "ssh"
user = "root"
password = vcd_vapp_vm.nginx.customization[0].admin_password
host = var.vcd_edge_external_ip
port = "58301"
timeout = "30s"
}
}
provisioner "remote-exec" {
inline = [
"chmod +x /tmp/prepare.sh", "./tmp/prepare.sh"
]
}
E descreveremos imediatamente a atualização do Bitrix.
Um exemplo de provisionamento 1C-Bitrix.
resource "null_resource" "install_update_bitrix" {
provisioner "remote-exec" {
connection {
type = "ssh"
user = "root"
password = vcd_vapp_vm.bitrix.customization[0].admin_password
host = var.vcd_edge_external_ip
port = "58302"
timeout = "60s"
}
inline = [
"yum -y update && yum -y upgrade",
"yum -y install wget nano epel-release net-tools unzip zip",
"wget http://repos.1c-bitrix.ru/yum/bitrix-env.sh -O /tmp/bitrix-env.sh",
"chmod +x /tmp/bitrix-env.sh",
"/tmp/bitrix-env.sh"
]
}
}
Importante! O script pode não funcionar se você não desabilitar o SELinux antecipadamente! Se você precisar de um artigo detalhado sobre como instalar e configurar o CMS 1C-Bitrix usando bitrix-env.sh, você pode .
3. Inicialização da infraestrutura
Inicializando módulos e plugins
Para o trabalho, usamos um simples “kit de cavalheiros”: um laptop com sistema operacional Windows 10 e um kit de distribuição do site oficial . Vamos descompactar e inicializar usando o comando: terraform.exe init
Após descrever a infraestrutura de computação e rede, iniciamos o planejamento para testar nossa configuração, onde podemos ver o que será criado e como será conectado entre si.
-
Execute o comando
- terraform plan -var-file=vcd.tfvars. -
Obtemos o resultado
- Plan: 16 to add, 0 to change, 0 to destroy.Ou seja, de acordo com esse plano, serão criados 16 recursos. -
Lançamos o plano sob comando
- terraform.exe apply -var-file=vcd.tfvars.
As máquinas virtuais serão criadas e, em seguida, os pacotes listados serão executados na seção do provisionador - o sistema operacional será atualizado e o CMS Bitrix será instalado.
Recebendo informações de conexão
Após executar o plano, queremos receber os dados em formato de texto para conexão aos servidores, para isso formataremos a seção de saída da seguinte forma:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
E a seguinte saída nos informa a senha da máquina virtual criada:
Outputs: nginx_password = F#4u8!!N
Como resultado, temos acesso a máquinas virtuais com sistema operacional atualizado e pacotes pré-instalados para nosso trabalho futuro. Tudo está pronto!
Mas e se você já tiver infraestrutura existente?
3.1. Trabalhando o Terraform com a infraestrutura existente
É simples: você pode importar máquinas virtuais atuais e seus contêineres vApp usando o comando import.
Vamos descrever o recurso vAPP e a máquina virtual.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
A próxima etapa é importar as propriedades dos recursos do vApp no formato vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, onde:
-
vApp - nome do vApp;
-
org — nome da organização;
-
org_vdc — nome do data center virtual.
Importando propriedades de recursos do vAPP
Vamos importar as propriedades dos recursos da VM no formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, no qual:
-
VM – nome da VM;
-
vApp - nome do vApp;
-
org — nome da organização;
-
orgvdc é o nome do data center virtual.
A importação foi bem-sucedida
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importing from ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import prepared!
Prepared vcd_vapp_vm for import
vcd_vapp_vm.Zabbix: Refreshing state... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import successful!
The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.
Agora podemos ver o novo recurso importado:
Recurso importado
> terraform show
...
# vcd_vapp.Monitoring:
resource "vcd_vapp" "Monitoring" {
guest_properties = {}
href = "https://vcloud.mclouds.ru/api/vApp/vapp-fe5db285-a4af-47c4-93e8-55df92f006ec"
id = "urn:vcloud:vapp:fe5db285-a4af-47c4-93e8-55df92f006ec"
ip = "allocated"
metadata = {}
name = "Monitoring"
org = "mClouds"
status = 4
status_text = "POWERED_ON"
vdc = "mClouds"
}
…
# vcd_vapp_vm.Zabbix:
resource "vcd_vapp_vm" "Zabbix" {
computer_name = "Zabbix"
cpu_cores = 1
cpus = 2
expose_hardware_virtualization = false
guest_properties = {}
hardware_version = "vmx-14"
href = "https://vcloud.mclouds.ru/api/vApp/vm-778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
id = "urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
internal_disk = [
{
bus_number = 0
bus_type = "paravirtual"
disk_id = "2000"
iops = 0
size_in_mb = 122880
storage_profile = "Gold Storage Policy"
thin_provisioned = true
unit_number = 0
},
]
memory = 8192
metadata = {}
name = "Zabbix"
org = "mClouds"
os_type = "centos8_64Guest"
storage_profile = "Gold Storage Policy"
vapp_name = "Monitoring"
vdc = "mClouds"
customization {
allow_local_admin_password = true
auto_generate_password = true
change_sid = false
enabled = false
force = false
join_domain = false
join_org_domain = false
must_change_password_on_first_login = false
number_of_auto_logons = 0
}
network {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Agora estamos definitivamente prontos - concluímos o último ponto (importar para a infraestrutura existente) e consideramos todos os pontos principais do trabalho com o Terraform.
A ferramenta revelou-se muito prática e permite descrever sua infraestrutura como código, desde máquinas virtuais de um provedor de nuvem até a descrição dos recursos dos componentes de rede.
Ao mesmo tempo, a independência do ambiente permite trabalhar com recursos locais, da nuvem e até mesmo gerenciar a plataforma. E se não houver nenhuma plataforma suportada e você quiser adicionar uma nova, você pode escrever seu próprio provedor e usá-lo.
Fonte: habr.com