En este artículo veremos en qué consiste Terraform y también lanzaremos gradualmente nuestra propia infraestructura. — prepararemos tres máquinas virtuales para diferentes propósitos: proxy, almacenamiento de archivos y CMS.
Sobre todo en detalle y en tres etapas:
1. Terraform: descripción, ventajas y componentes
Terraform es una herramienta IaC (Infraestructura como código) para construir y administrar infraestructura virtual utilizando código.
Notamos varias ventajas al trabajar con la herramienta:
-
Velocidad de implementación de nuevos inquilinos (entornos virtuales personalizados). Normalmente, cuantos más clientes nuevos haya, más “clics” deberá hacer el personal de soporte técnico para publicar nuevos recursos. Con Terraform, los usuarios pueden cambiar la configuración de la máquina virtual (por ejemplo, apagar automáticamente el sistema operativo y aumentar la partición del disco virtual) sin necesidad de soporte técnico ni apagar la máquina.
-
Verificación instantánea del plan de activación. nuevo inquilino. Usando la descripción del código de infraestructura, podemos verificar inmediatamente qué se agregará y en qué orden, así como en qué estado final estará esta o aquella máquina virtual o red virtual con conexiones a máquinas virtuales.
-
Capacidad para describir las plataformas en la nube más populares. Puedes usar la herramienta desde Amazon y Google Cloud, hasta plataformas privadas basadas en VMware vCloud Director, ofreciendo servicios dentro de soluciones IaaS, SaaS y PaaS.
-
Gestione múltiples proveedores de nube y distribuir la infraestructura entre ellos para mejorar la tolerancia a fallos, utilizando una única configuración para crear, diagnosticar y gestionar los recursos de la nube.
-
Uso conveniente para crear stands de demostración para pruebas y depuración de software. Puede crear y transferir soportes para el departamento de pruebas, probar software en diferentes entornos en paralelo y cambiar y eliminar recursos instantáneamente creando un solo plan de creación de recursos.
Terraform "terrario"
Hablamos brevemente de las ventajas de la herramienta, ahora analicémosla en sus componentes.
Proveedores.
En Terraform, casi cualquier tipo de infraestructura puede representarse como un recurso. La conexión entre los recursos y la plataforma API la proporcionan los módulos del proveedor, que le permiten crear recursos dentro de una plataforma específica, por ejemplo, Azure o VMware vCloud Director.
Como parte del proyecto, podrás interactuar con diferentes proveedores en diferentes plataformas.
Recursos (descripción del recurso).
La descripción de recursos le permite administrar componentes de la plataforma, como máquinas virtuales o redes.
Puede crear usted mismo una descripción de recurso para el proveedor de VMware vCloud Director y utilizar esta descripción para crear recursos con cualquier proveedor de alojamiento que utilice vCloud Director. Solo necesita cambiar los parámetros de autenticación y los parámetros de conexión de red al proveedor de alojamiento requerido
Proveedores.
Este componente permite realizar operaciones para la instalación inicial y el mantenimiento del sistema operativo después de crear máquinas virtuales. Una vez que haya creado un recurso de máquina virtual, puede utilizar aprovisionadores para configurar y conectarse a través de SSH, actualizar el sistema operativo y descargar y ejecutar un script.
Variables de entrada y salida.
Variables de entrada: variables de entrada para cualquier tipo de bloque.
Las variables de salida le permiten guardar valores después de crear recursos y pueden usarse como variables de entrada en otros módulos, por ejemplo en el bloque Aprovisionadores.
Estados.
Los archivos de estados almacenan información sobre la configuración de los recursos de la plataforma del proveedor. Cuando se crea la plataforma por primera vez, no hay información sobre los recursos y antes de cualquier operación, Terraform actualiza el estado con la infraestructura real de los recursos ya descritos.
El objetivo principal de los estados es guardar un montón de objetos de recursos ya creados para comparar la configuración de recursos y objetos agregados para evitar creaciones y cambios repetidos en la plataforma.
De forma predeterminada, la información de estado se almacena en el archivo local terraform.tfstate, pero si es necesario, es posible utilizar el almacenamiento remoto para el trabajo en equipo.
También puede importar recursos de plataforma actuales al estado para interactuar aún más con otros recursos que a su vez se crearon sin la ayuda de Terraform.
2. Creación de infraestructura
Se han ordenado los componentes, ahora usando Terraform crearemos gradualmente una infraestructura con tres máquinas virtuales. El primero con el servidor proxy nginx instalado, el segundo con almacenamiento de archivos basado en Nextcloud y el tercero con CMS Bitrix.
Escribiremos código y lo ejecutaremos usando nuestro ejemplo. . Nuestros usuarios reciben una cuenta con derechos de administrador de la organización. Si utiliza una cuenta con los mismos derechos en otra nube de VMware, puede reproducir el código de nuestros ejemplos. ¡Ir!
Primero, creemos un directorio para nuestro nuevo proyecto en el que se colocarán los archivos que describen la infraestructura.
mkdir project01
A continuación, describimos los componentes de la infraestructura. Terraform crea relaciones y procesa archivos según la descripción de los archivos. Los archivos en sí pueden recibir nombres según el propósito de los bloques que se describen, por ejemplo, network.tf: describe los parámetros de red para la infraestructura.
Para describir los componentes de nuestra infraestructura, creamos los siguientes archivos:
Lista de archivos.
main.tf: descripción de los parámetros del entorno virtual: máquinas virtuales, contenedores virtuales;
network.tf: descripción de los parámetros de la red virtual y las reglas de NAT y Firewall;
variables.tf: lista de variables que utilizamos;
vcd.tfvars: valores de las variables del proyecto para el módulo VMware vCloud Director.
El lenguaje de configuración en Terraform es declarativo y el orden de los bloques no importa, excepto los bloques de aprovisionamiento, porque en este bloque describimos los comandos a ejecutar al preparar la infraestructura y se ejecutarán en orden.
Estructura de bloques.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Para describir los bloques se utiliza su propio lenguaje de programación HCL (HashiCorp Configuration Language), es posible describir la infraestructura utilizando JSON. Puedes aprender más sobre la sintaxis. .
Configuración de variables de entorno, variables.tf y vcd.tfvars
Primero, creemos dos archivos que describan la lista de todas las variables utilizadas y sus valores para el módulo VMware vCloud Director. Primero, creemos el archivo variables.tf.
Contenido del archivo 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 del proveedor.
-
vcd_org_user: nombre de usuario con derechos de administrador de la organización,
-
vcd_org_password — contraseña de usuario,
-
vcd_org — nombre de la organización,
-
vcd_org_vdc — nombre del centro de datos virtual,
-
vcd_org_url - URL de API,
-
vcd_org_edge_name — nombre del enrutador virtual,
-
vcd_org_catalog — nombre del directorio con plantillas de máquinas virtuales,
-
vcd_edge_external_ip — dirección IP pública,
-
vcd_edge_external_network — nombre de la red externa,
-
vcd_org_hdd_sp — nombre de la política de almacenamiento del disco duro,
-
vcd_org_ssd_sp: nombre de la política de almacenamiento SSD.
E ingresa nuestras variables:
-
vcd_edge_local_ip_nginx — Dirección IP de la máquina virtual con NGINX,
-
vcd_edge_local_ip_bitrix: dirección IP de la máquina virtual con 1C: Bitrix,
-
vcd_edge_local_ip_nextcloud: dirección IP de la máquina virtual con Nextcloud.
Con el segundo archivo creamos y especificamos variables para el módulo VMware vCloud Director en el archivo vcd.tfvars: Recordemos que en nuestro ejemplo usamos , si trabajas con otro proveedor, consulta los valores con él.
Contenido del archivo 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 de red, network.tf.
Las variables de entorno están configuradas, ahora configuraremos el esquema de conexión de la máquina virtual: asignaremos una dirección IP privada a cada máquina virtual y usaremos NAT de destino para "reenviar" los puertos a la red externa. Para limitar el acceso a los puertos de administración, configuraremos el acceso solo para nuestra dirección IP.
Se está creando el diagrama de red para la plataforma Terraform
Creamos una red organizacional virtual con el nombre net_lan01, la puerta de enlace predeterminada: 192.168.110.254, y también con el espacio de direcciones: 192.168.110.0/24.
Describimos una red 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"
}
}
Creemos reglas de firewall que permitan que las máquinas virtuales accedan a Internet. Dentro de este bloque, todos los recursos virtuales en la nube tendrán acceso a Internet:
Describimos las reglas para el 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 la dependencia que luego de procesar el bloque vcdnetworkrouted.net procedemos a configurar el bloque vcdnsxvfirewallrule, vía depende de. Usamos esta opción porque algunas dependencias pueden reconocerse implícitamente en la configuración.
A continuación crearemos reglas que permitan el acceso a puertos desde la red externa e indicaremos nuestra dirección IP para conectarnos vía SSH a los servidores. Cualquier usuario de Internet tiene acceso a los puertos 80 y 443 del servidor web, y un usuario con una dirección IP 90.1.15.1 tiene acceso a los puertos SSH de los servidores virtuales.
Permitir el acceso a puertos desde la red 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 reglas Source NAT para acceder a Internet desde una red local en la nube:
Describimos las reglas de 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]
}
Y para completar la configuración del bloque de red, agregamos reglas NAT de Destino para acceder a servicios desde la red externa:
Agregar reglas 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]
}
Agregue una regla NAT para la traducción de puertos al 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]
}
Agregue una regla NAT para la traducción de puertos al 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]
}
Agregue una regla NAT para la traducción de puertos al 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 del entorno virtual main.tf
Como planeamos al principio del artículo, crearemos tres máquinas virtuales. Se prepararán mediante "Personalización de invitados". Configuraremos los parámetros de red de acuerdo con la configuración que especificamos y la contraseña de usuario se generará automáticamente.
Describamos la vApp en la que se ubicarán las máquinas virtuales y su configuración.
Configuración de máquina virtual
Creemos un contenedor de vApp. Para que podamos conectar inmediatamente la vApp y la VM a la red virtual, también agregamos el parámetro depend_on:
Crear un contenedor
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Creemos una máquina virtual con una descripció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 principales en la descripción de la VM:
-
nombre: nombre de la máquina virtual,
-
vappname: nombre de la vApp a la que agregar una nueva VM,
-
nombre de catálogo / nombre de plantilla: nombre del catálogo y nombre de la plantilla de la máquina virtual,
-
perfil de almacenamiento: política de almacenamiento predeterminada.
Parámetros del bloque de red:
-
tipo — tipo de red conectada,
-
nombre: a qué red virtual conectar la VM,
-
isprimary - adaptador de red principal,
-
ipallocation_mode: modo de asignación de direcciones MANUAL / DHCP / POOL,
-
ip: dirección IP de la máquina virtual, la especificaremos manualmente.
bloque override_template_disk:
-
sizeinmb: tamaño del disco de arranque para la máquina virtual
-
Storage_profile: política de almacenamiento para el disco.
Creemos una segunda VM con una descripción del almacenamiento de archivos 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 ]
}
En la sección vcdvminternal_disk describiremos un nuevo disco virtual que está conectado a la máquina virtual.
Explicaciones para el bloque vcdvminternaldisk:
-
bustype - tipo de controlador de disco
-
sizeinmb - tamaño del disco
-
número de bus / número de unidad: ubicación de la conexión en el adaptador
-
Storage_profile: política de almacenamiento para el disco.
Describamos la última VM 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
}
}
Actualización del sistema operativo e instalación de scripts adicionales
Se prepara la red, se describen las máquinas virtuales. Antes de importar nuestra infraestructura podemos realizar un aprovisionamiento inicial por adelantado utilizando bloques de aprovisionamiento y sin utilizar Ansible.
Veamos cómo actualizar el sistema operativo y ejecutar el script de instalación de CMS Bitrix usando el bloque de aprovisionamiento.
Primero, instalemos los 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" ]
}
}
}
Designación de componentes:
-
aprovisionador “remote-exec”: conecta el bloque de aprovisionamiento remoto
-
En el bloque de conexión describimos el tipo y los parámetros de la conexión:
-
tipo — protocolo, en nuestro caso SSH;
-
usuario — nombre de usuario;
-
contraseña: contraseña de usuario. En nuestro caso, apuntamos al parámetro vcdvappvm.nginx.customization[0].admin_password, que almacena la contraseña generada para el usuario del sistema.
-
host: dirección IP externa para la conexión;
-
puerto — puerto para la conexión, que se especificó previamente en la configuración de DNAT;
-
en línea: enumera la lista de comandos que se ingresarán. Los comandos se ingresarán en el orden indicado en esta sección.
Como ejemplo, ejecutemos adicionalmente el script de instalación de 1C-Bitrix. El resultado de la ejecución del script estará disponible mientras se ejecuta el plan. Para instalar el script, primero describimos el bloque:
Describamos la 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 inmediatamente describiremos la actualización de Bitrix.
Un ejemplo de aprovisionamiento de 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! ¡Es posible que el script no funcione si no desactiva SELinux de antemano! Si necesita un artículo detallado sobre cómo instalar y configurar CMS 1C-Bitrix usando bitrix-env.sh, puede hacerlo .
3. Inicialización de la infraestructura
Inicializando módulos y complementos
Para trabajar utilizamos un sencillo "kit de caballero": una computadora portátil con sistema operativo Windows 10 y una distribución del sitio web oficial. . Descomprimamos e inicialicemos usando el comando: terraform.exe init
Después de describir la infraestructura informática y de red, lanzamos la planificación para probar nuestra configuración, donde podremos ver qué se creará y cómo se conectarán entre sí.
-
Ejecutar el comando
- terraform plan -var-file=vcd.tfvars. -
Obtenemos el resultado
- Plan: 16 to add, 0 to change, 0 to destroy.Es decir, según este plan se crearán 16 recursos. -
Lanzamos el plan a la orden.
- terraform.exe apply -var-file=vcd.tfvars.
Se crearán máquinas virtuales y luego los paquetes que hemos enumerado se ejecutarán dentro de la sección del aprovisionador: se actualizará el sistema operativo y se instalará CMS Bitrix.
Recibir datos de conexión
Luego de ejecutar el plan, queremos recibir datos en forma de texto para conectarnos a los servidores, para esto formatearemos la sección de salida de la siguiente manera:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
Y el siguiente resultado nos dice la contraseña de la máquina virtual creada:
Outputs: nginx_password = F#4u8!!N
Como resultado, obtenemos acceso a máquinas virtuales con un sistema operativo actualizado y paquetes preinstalados para nuestro trabajo posterior. ¡Todo está listo!
Pero ¿qué pasa si ya tienes una infraestructura existente?
3.1. Trabajar Terraform con la infraestructura existente
Es simple, puede importar máquinas virtuales actuales y sus contenedores de vApp usando el comando de importación.
Describamos el recurso vAPP y la 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"
}
El siguiente paso es importar las propiedades de los recursos de vApp en el formato vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, donde:
-
vApp: nombre de la vApp;
-
org — nombre de la organización;
-
org_vdc: nombre del centro de datos virtual.
Importación de propiedades de recursos vAPP
Importemos las propiedades de los recursos de VM en el formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, en el cual:
-
VM: nombre de la VM;
-
vApp: nombre de la vApp;
-
org — nombre de la organización;
-
orgvdc es el nombre del centro de datos virtual.
La importación fue exitosa
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.
Ahora podemos ver el nuevo 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"
}
}
Ahora estamos definitivamente listos: hemos terminado con el último punto (importar a la infraestructura existente) y hemos considerado todos los puntos principales del trabajo con Terraform.
La herramienta resultó ser muy conveniente y le permite describir su infraestructura como código, desde las máquinas virtuales de un proveedor de la nube hasta describir los recursos de los componentes de la red.
Al mismo tiempo, la independencia del entorno permite trabajar con recursos locales en la nube e incluso gestionar la plataforma. Y si no hay una plataforma compatible y desea agregar una nueva, puede escribir su propio proveedor y usarlo.
Fuente: habr.com