Neste artigo veremos en que consiste Terraform, e tamén lanzaremos aos poucos a nosa propia infraestrutura — prepararemos tres máquinas virtuales para diferentes propósitos: proxy, almacenamento de ficheiros e CMS.
Sobre todo en detalle e en tres etapas:
1. Terraform - descrición, vantaxes e compoñentes
Terraform é unha ferramenta IaC (Infrastructure-as-Code) para construír e xestionar infraestrutura virtual mediante código.
Observamos varias vantaxes ao traballar coa ferramenta:
-
Velocidade de implantación dos novos inquilinos (entornos virtuais personalizados). Normalmente, cantos máis novos clientes haxa, máis "clics" debe facer o persoal de soporte técnico para publicar novos recursos. Con Terraform, os usuarios poden cambiar a configuración da máquina virtual (por exemplo, apagando automaticamente o sistema operativo e aumentando a partición do disco virtual) sen necesitar asistencia técnica nin apagar a propia máquina.
-
Verificación instantánea do plan de activación novo Tennant. Mediante a descrición do código de infraestrutura, podemos comprobar inmediatamente que se engadirá e en que orde, así como en que estado final estará tal ou aquela máquina virtual ou rede virtual con conexións a máquinas virtuais.
-
Capacidade para describir as plataformas de nube máis populares. Podes usar a ferramenta desde Amazon e Google Cloud, ata plataformas privadas baseadas en VMware vCloud Director, que ofrecen servizos dentro de solucións IaaS, SaaS e PaaS.
-
Xestiona varios provedores de nube e distribuír a infraestrutura entre eles para mellorar a tolerancia a fallos, utilizando unha única configuración para crear, diagnosticar e xestionar os recursos da nube.
-
Uso cómodo para crear stands de demostración para probas e depuración de software. Podes crear e transferir soportes para o departamento de probas, probar software en diferentes ambientes en paralelo e cambiar e eliminar recursos ao instante creando só un plan de creación de recursos.
Terraform "Terrarium".
Falamos brevemente sobre as vantaxes da ferramenta, agora imos desglosala nos seus compoñentes
Provedores.
En Terraform pódese representar como recurso case calquera tipo de infraestrutura. A conexión entre os recursos e a plataforma API é proporcionada por módulos de provedores, que permiten crear recursos dentro dunha plataforma específica, por exemplo, Azure ou VMware vCloud Director.
Como parte do proxecto, podes interactuar con diferentes provedores en diferentes plataformas.
Recursos (descrición do recurso).
A descrición de recursos permítelle xestionar compoñentes da plataforma, como máquinas virtuais ou redes.
Pode crear vostede mesmo unha descrición de recursos para o provedor de VMware vCloud Director e utilizar esta descrición para crear recursos con calquera provedor de hospedaxe que utilice vCloud Director. Só precisa cambiar os parámetros de autenticación e os parámetros de conexión de rede ao provedor de hospedaxe necesario
Provedores.
Este compoñente permite realizar operacións para a instalación inicial e o mantemento do sistema operativo despois de crear máquinas virtuais. Unha vez que creas un recurso de máquina virtual, podes usar provedores para configurar e conectarte a través de SSH, actualizar o sistema operativo e descargar e executar un script.
Variables de entrada e saída.
Variables de entrada: variables de entrada para calquera tipo de bloque.
As variables de saída permítenche gardar valores despois de crear recursos e pódense usar como variables de entrada noutros módulos, por exemplo no bloque Provisioners.
Estados.
Os ficheiros States almacenan información sobre a configuración dos recursos da plataforma do provedor. Cando se crea a plataforma por primeira vez, non hai información sobre os recursos e antes de calquera operación, Terraform actualiza o estado coa infraestrutura real dos recursos xa descritos.
O propósito principal dos estados é gardar unha morea de obxectos de recursos xa creados para comparar a configuración de recursos e obxectos engadidos para evitar a creación e cambios repetidos na plataforma.
Por defecto, a información do estado gárdase no ficheiro terraform.tfstate local, pero se é necesario, é posible utilizar o almacenamento remoto para o traballo en equipo.
Tamén pode importar os recursos actuais da plataforma ao estado para seguir interactuando con outros recursos que á súa vez foron creados sen a axuda de Terraform.
2. Creación de infraestruturas
Os compoñentes foron resoltos, agora usando Terraform iremos creando pouco a pouco unha infraestrutura con tres máquinas virtuais. O primeiro co servidor proxy nginx instalado, o segundo con almacenamento de ficheiros baseado en Nextcloud e o terceiro con CMS Bitrix.
Escribiremos código e executarémolo usando o noso exemplo . Os nosos usuarios reciben unha conta con dereitos de administrador da organización. Se usas unha conta cos mesmos dereitos noutra nube de VMware, podes reproducir o código dos nosos exemplos. Vaia!
En primeiro lugar, imos crear un directorio para o noso novo proxecto no que se colocarán os ficheiros que describen a infraestrutura.
mkdir project01
A continuación, describimos os compoñentes da infraestrutura. Terraform crea relacións e procesa ficheiros en función da descrición dos ficheiros. Os propios ficheiros pódense nomear en función do propósito dos bloques que se describen, por exemplo, network.tf: describe os parámetros de rede para a infraestrutura.
Para describir os compoñentes da nosa infraestrutura, creamos os seguintes ficheiros:
Lista de ficheiros.
main.tf - descrición dos parámetros para o contorno virtual - máquinas virtuais, contedores virtuais;
network.tf: descrición dos parámetros da rede virtual e das regras de NAT e Firewall;
variables.tf - lista de variables que usamos;
vcd.tfvars: valores das variables do proxecto para o módulo VMware vCloud Director.
A linguaxe de configuración en Terraform é declarativa e a orde dos bloques non importa, excepto para os bloques de aprovisionamento, porque neste bloque describimos os comandos a executar ao preparar a infraestrutura e executaranse en orde.
Estrutura do bloque.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Para describir bloques utilízase a súa propia linguaxe de programación HCL (HashiCorp Configuration Language), é posible describir a infraestrutura mediante JSON. Podes aprender máis sobre a sintaxe .
Configuración da variable de ambiente, variables.tf e vcd.tfvars
En primeiro lugar, imos crear dous ficheiros que describen a lista de todas as variables utilizadas e os seus valores para o módulo VMware vCloud Director. Primeiro, imos crear o ficheiro variables.tf.
Contido do ficheiro variables.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 variables que recibimos do provedor.
-
vcd_org_user — nome de usuario con dereitos de administrador da organización,
-
vcd_org_password — contrasinal de usuario,
-
vcd_org — nome da organización,
-
vcd_org_vdc — nome do centro de datos virtual,
-
vcd_org_url - URL da API,
-
vcd_org_edge_name — nome do enrutador virtual,
-
vcd_org_catalog — nome do directorio con modelos de máquina virtual,
-
vcd_edge_external_ip — enderezo IP público,
-
vcd_edge_external_network — nome da rede externa,
-
vcd_org_hdd_sp — nome da política de almacenamento do disco duro,
-
vcd_org_ssd_sp — nome da política de almacenamento SSD.
E introduza as nosas variables:
-
vcd_edge_local_ip_nginx — enderezo IP da máquina virtual con NGINX,
-
vcd_edge_local_ip_bitrix: enderezo IP da máquina virtual con 1C: Bitrix,
-
vcd_edge_local_ip_nextcloud — Enderezo IP da máquina virtual con Nextcloud.
Co segundo ficheiro creamos e especificamos variables para o módulo VMware vCloud Director no ficheiro vcd.tfvars: Lembremos que no noso exemplo usamos , se traballa con outro provedor, comprobe os valores con eles.
Contido do ficheiro 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"
Configuración da rede, network.tf.
As variables de ambiente están configuradas, agora configuraremos o esquema de conexión da máquina virtual: asignaremos un enderezo IP privado a cada máquina virtual e usaremos o NAT de destino para "reenviar" os portos á rede externa. Para limitar o acceso aos portos de xestión, estableceremos o acceso só para o noso enderezo IP.
Diagrama de rede para a plataforma Terraform que se está creando
Creamos unha rede organizativa virtual co nome net_lan01, a pasarela predeterminada: 192.168.110.254, e tamén co espazo de enderezos: 192.168.110.0/24.
Describimos unha 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"
}
}
Imos crear regras de firewall que permitan ás máquinas virtuais acceder a Internet. Dentro deste bloque, todos os recursos virtuais da nube terán acceso a Internet:
Describimos as regras para o acceso de VM a 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]
}
Establecida a dependencia de que despois de procesar o bloque vcdnetworkrouted.net, procedamos a configurar o bloque vcdnsxvfirewallrule, mediante o uso depende. Usamos esta opción porque algunhas dependencias poden recoñecerse implicitamente na configuración.
A continuación, crearemos regras que permitan o acceso a portos desde a rede externa e indicaremos o noso enderezo IP para conectarnos mediante SSH aos servidores. Calquera usuario de Internet ten acceso aos portos 80 e 443 do servidor web, e un usuario cun enderezo IP 90.1.15.1 ten acceso aos portos SSH dos servidores virtuais.
Permitir o acceso aos portos desde a 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]
}
Creamos regras NAT de orixe para acceder a Internet desde unha rede local na nube:
Describimos as regras de NAT de orixe.
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 configuración do bloque de rede, engadimos regras Destination NAT para acceder aos servizos desde a rede externa:
Engadindo regras de 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]
}
Engade unha regra NAT para a tradución de portos ao servidor SSH en 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]
}
Engade unha regra NAT para a tradución de portos ao servidor SSH con 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]
}
Engade unha regra NAT para a tradución de portos ao servidor SSH con 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]
}
Configuración do contorno virtual Main.tf
Como planeamos ao comezo do artigo, crearemos tres máquinas virtuais. Prepararanse mediante "Personalización de invitados". Estableceremos os parámetros de rede segundo a configuración que especificamos e xerarase automaticamente o contrasinal do usuario.
Imos describir a vApp na que se localizarán as máquinas virtuais e a súa configuración.
Configuración da máquina virtual
Imos crear un contenedor vApp. Para que poidamos conectar inmediatamente a vApp e a máquina virtual á rede virtual, tamén engadimos o parámetro depends_on:
Crear un recipiente
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Imos crear unha máquina virtual cunha descrición
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
}
}
Parámetros principais na descrición da máquina virtual:
-
nome — nome da máquina virtual,
-
vappname - nome da vApp á que engadir unha nova máquina virtual,
-
catalogname / templatename - nome do catálogo e nome do modelo da máquina virtual,
-
storageprofile - política de almacenamento predeterminada.
Parámetros do bloque de rede:
-
tipo — tipo de rede conectada,
-
nome: a que rede virtual conectar a máquina virtual,
-
isprimary - adaptador de rede principal,
-
ipallocation_mode — modo de asignación de enderezos MANUAL / DHCP / POOL,
-
ip — Enderezo IP para a máquina virtual, especificarémolo manualmente.
bloque override_template_disk:
-
sizeinmb — tamaño do disco de arranque para a máquina virtual
-
storage_profile — política de almacenamento para o disco
Imos crear unha segunda máquina virtual cunha descrición do almacenamento de ficheiros de 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 sección vcdvminternal_disk imos describir un novo disco virtual que está conectado á máquina virtual.
Explicacións para o bloque vcdvmininternaldisk:
-
bustype - tipo de controlador de disco
-
sizeinmb — tamaño do disco
-
busnumber / unitnumber - localización da conexión no adaptador
-
storage_profile — política de almacenamento para o disco
Imos describir a última máquina virtual en 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
}
}
Actualizando o sistema operativo e instalando scripts adicionais
Prepárase a rede, descríbense as máquinas virtuais. Antes de importar a nosa infraestrutura, podemos realizar o aprovisionamento inicial con antelación utilizando bloques de aprovisionamento e sen utilizar Ansible.
Vexamos como actualizar o sistema operativo e executar o script de instalación de CMS Bitrix usando o bloque de aprovisionamento.
Primeiro, imos instalar os paquetes de actualización de 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" ]
}
}
}
Denominación dos compoñentes:
-
provisioner "remote-exec": conecte o bloque de aprovisionamento remoto
-
No bloque de conexión describimos o tipo e os parámetros da conexión:
-
tipo — protocolo, no noso caso SSH;
-
usuario — nome de usuario;
-
contrasinal — contrasinal do usuario. No noso caso, apuntamos ao parámetro vcdvappvm.nginx.customization[0].admin_password, que almacena o contrasinal xerado para o usuario do sistema.
-
host — enderezo IP externo para a conexión;
-
port — porto para a conexión, que se especificou anteriormente na configuración de DNAT;
-
en liña: lista a lista de comandos que se introducirán. Os comandos introduciranse na orde indicada nesta sección.
Como exemplo, executemos ademais o script de instalación de 1C-Bitrix. A saída do resultado da execución do script estará dispoñible mentres se executa o plan. Para instalar o script, primeiro describimos o bloque:
Imos describir a instalación de 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 describiremos inmediatamente a actualización de Bitrix.
Un exemplo de aprovisionamento 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! É posible que o script non funcione se non desactiva SELinux con antelación. Se precisa un artigo detallado sobre a instalación e configuración de CMS 1C-Bitrix usando bitrix-env.sh, oo pode .
3. Iniciación da infraestrutura
Inicialización de módulos e complementos
Para traballar, usamos un simple "kit de cabaleiro": un portátil con sistema operativo Windows 10 e un kit de distribución do sitio web oficial . Imos desempaquetar e inicializar usando o comando: terraform.exe init
Despois de describir a infraestrutura informática e de rede, lanzamos a planificación para probar a nosa configuración, onde podemos ver o que se creará e como se conectará entre si.
-
Executar o comando
- terraform plan -var-file=vcd.tfvars. -
Conseguimos o resultado
- Plan: 16 to add, 0 to change, 0 to destroy.É dicir, segundo este plan, crearanse 16 recursos. -
Lanzamos o plan ao mando
- terraform.exe apply -var-file=vcd.tfvars.
Crearanse máquinas virtuais e, a continuación, executaranse os paquetes que enumeramos na sección de aprovisionamento: actualizarase o SO e instalarase CMS Bitrix.
Recibindo información de conexión
Despois de executar o plan, queremos recibir datos en forma de texto para conectarnos aos servidores, para iso formataremos a sección de saída do seguinte xeito:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
E a seguinte saída indícanos o contrasinal para a máquina virtual creada:
Outputs: nginx_password = F#4u8!!N
Como resultado, temos acceso a máquinas virtuais cun sistema operativo actualizado e paquetes preinstalados para o noso traballo posterior. Todo listo!
Pero e se xa tes unha infraestrutura existente?
3.1. Terraform traballando coa infraestrutura existente
É sinxelo, pode importar máquinas virtuais actuais e os seus contedores de vApp usando o comando de importación.
Imos describir 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"
}
O seguinte paso é importar as propiedades dos recursos de vApp no formato vcdvapp.<vApp> <org>.<orgvdc>.<vApp>onde:
-
vApp - nome da vApp;
-
org — nome da organización;
-
org_vdc — nome do centro de datos virtual.
Importando propiedades de recursos vAPP
Imos importar as propiedades dos recursos de VM no formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, en que:
-
VM - Nome da máquina virtual;
-
vApp - nome da vApp;
-
org — nome da organización;
-
orgvdc é o nome do centro de datos virtual.
A importación realizouse correctamente
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 listos: rematamos co último punto (importar a infraestrutura existente) e consideramos todos os puntos principais de traballar con Terraform.
A ferramenta resultou moi cómoda e permíteche describir a túa infraestrutura como código, empezando desde máquinas virtuais dun provedor de nube ata describir os recursos dos compoñentes da rede.
Ao mesmo tempo, a independencia do entorno permite traballar con recursos locais, na nube, e mesmo xestionar a plataforma. E se non hai unha plataforma compatible e queres engadir unha nova, podes escribir o teu propio provedor e usalo.
Fonte: www.habr.com