En este artículo analizaremos de qué se compone Terraform y lanzaremos nuestra propia infraestructura paso a paso. — prepararemos tres VM para diferentes propósitos: proxy, almacenamiento de archivos y CMS.
Todo detallado y en tres etapas:
1. Terraform: descripción, ventajas y componentes
Terraform es una herramienta IaC (Infrastructure-as-Code) para construir y gestionar infraestructura virtual mediante código.
En la utilización de la herramienta, hemos destacado varias ventajas:
Velocidad de despliegue de nuevos inquilinos (entornos virtuales de usuario). Generalmente, cuanto más clientes nuevos hay, más "clics" deben hacer los empleados del soporte técnico para publicar nuevos recursos. Con Terraform, los usuarios pueden modificar los parámetros de las máquinas virtuales (por ejemplo, apagar el sistema operativo automáticamente y aumentar la partición del disco virtual) sin la intervención del soporte técnico y sin apagar la máquina misma.
Verificación instantánea del plan de activación de un nuevo inquilino. Con la descripción del código de infraestructura, podemos verificar de inmediato qué y en qué orden se añadirá, así como en qué estado final estará una u otra máquina virtual o red virtual con conexiones a máquinas virtuales.
Posibilidad de describir la mayoría de las plataformas en la nube populares. Puede utilizar la herramienta desde Amazon y Google Cloud hasta plataformas privadas basadas en VMware vCloud Director que ofrecen servicios en el marco de soluciones IaaS, SaaS y PaaS.
Gestionar varios proveedores de nube y distribuir la infraestructura entre ellos para mejorar la resiliencia, utilizando una única configuración para crear, diagnosticar y gestionar recursos en la nube.
Uso conveniente para crear bancos de pruebas para la prueba y depuración de software. Puede crear y transferir bancos de pruebas para el departamento de pruebas, revisar el software en diferentes entornos simultáneamente, así como cambiar y eliminar recursos al instante, creando solo un plan de construcción de recursos.
El «Terrario» de Terraform
Hemos comentado brevemente las ventajas de la herramienta, ahora desglosaremos sus componentes.
Proveedores.
En Terraform, prácticamente cualquier tipo de infraestructura puede representarse como un recurso. La conexión entre los recursos y la plataforma API se establece a través de módulos de providers que permiten crear recursos dentro de una plataforma específica, como Azure o VMware vCloud Director.
En el marco del proyecto, puedes interactuar con diferentes proveedores en diferentes plataformas.
Resources (descripción de recursos).
La descripción de recursos permite gestionar los componentes de la plataforma, como máquinas virtuales o redes.
Puedes crear tu propia descripción de recursos para el proveedor VMware vCloud Director y utilizar esta descripción para crear recursos en cualquier proveedor de hosting que use vCloud Director. Solo tendrás que reemplazar los parámetros de autenticación y las configuraciones de red necesarias para el proveedor de hosting.
Provisioners.
Este componente permite realizar operaciones de instalación inicial y mantenimiento del sistema operativo tras la creación de máquinas virtuales. Una vez creado el recurso de la máquina virtual, puedes configurarlo y conectarte por SSH, actualizar el sistema operativo, y cargar y ejecutar un script a través de los provisioners.
Variables Input y Output.
Las variables Input son las variables de entrada para cualquier tipo de bloques.
Las variables Output permiten guardar valores después de la creación de recursos y pueden utilizarse como variables de entrada en otros módulos, por ejemplo, en el bloque Provisioners.
States (estados).
Los archivos de States almacenan información sobre la configuración de los recursos de la plataforma del proveedor. Al crear 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 mantener un vínculo de objetos de recursos ya creados para comparar la configuración de los recursos que se van a añadir y los objetos, con el fin de evitar la recreación o modificación de la plataforma.
La información sobre el estado se almacena por defecto en un archivo local terraform.tfstate, pero si es necesario, existe la opción de utilizar almacenamiento remoto para trabajar en equipo.
También puedes importar los recursos actuales de la plataforma en el estado para interactuar con otros recursos que a su vez fueron creados sin la ayuda de Terraform.
2. Creación de infraestructura
Los componentes se han desglosado, ahora con Terraform crearemos la infraestructura por etapas con tres máquinas virtuales. La primera tendrá un servidor proxy nginx instalado, la segunda un almacenamiento de archivos basado en Nextcloud y la tercera un CMS Bitrix.
Escribiremos el código y lo ejecutaremos usando nuestro . Nuestros usuarios obtienen una cuenta con derechos de Administrador de la Organización. Si usas una cuenta con los mismos derechos en otra nube de VMware, podrás reproducir el código de nuestros ejemplos. ¡Vamos!
Primero crearemos un directorio para nuestro nuevo proyecto, en el que se ubicarán los archivos con la descripción de la infraestructura.
mkdir project01
Luego describiremos los componentes de la infraestructura. Terraform crea relaciones y procesa archivos en función de las descripciones en los archivos. Los archivos se pueden nombrar según la finalidad de los bloques que describen, por ejemplo, network.tf describe los parámetros de red para la infraestructura.
Para describir los componentes de nuestra infraestructura, hemos creado los siguientes archivos:
Lista de archivos.
main.tf — descripción de los parámetros para el entorno virtual — máquinas virtuales, contenedores virtuales;
network.tf — descripción de los parámetros de la red virtual y las reglas de NAT, 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 para los bloques provisioner, ya que en este bloque describimos los comandos que se ejecutarán al preparar la infraestructura y se ejecutarán en orden.
Estructura de los bloques.
"" "" {
# Block body
= # Argumento
}
Para describir los bloques se utiliza un lenguaje de programación propio HCL (HashiCorp Configuration Language), también es posible describir la infraestructura utilizando JSON. Puedes .
Configuración de la variable de entorno, variables.tf y vcd.tfvars
Primero crearemos dos archivos que describen la lista de todas las variables utilizadas y sus valores para el módulo VMware vCloud Director. Primero crearemos el archivo variables.tf.
Contenido del archivo variables.tf.
variable "vcd_org_user" {
description = "Usuario de inquilino vCD"
}
variable "vcd_org_password" {
description = "Contraseña de inquilino vCD"
}
variable "vcd_org" {
description = "Organización vCD de inquilino"
}
variable "vcd_org_vdc" {
description = "VDC de inquilino vCD"
}
variable "vcd_org_url" {
description = "URL de inquilino vCD"
}
variable "vcd_org_max_retry_timeout" {
default = "60"
}
variable "vcd_org_allow_unverified_ssl" {
default = "true"
}
variable "vcd_org_edge_name" {
description = "Nombre del borde vCD"
}
variable "vcd_org_catalog" {
description = "Catálogo público vCD"
}
variable "vcd_template_os_centos7" {
description = "OS CentOS 7"
default = "CentOS7"
}
variable "vcd_org_ssd_sp" {
description = "Políticas de almacenamiento"
default = "Política de almacenamiento Oro"
}
variable "vcd_org_hdd_sp" {
description = "Políticas de almacenamiento"
default = "Política de almacenamiento Bronce"
}
variable "vcd_edge_local_subnet" {
description = "Subnet de red de la organización"
}
variable "vcd_edge_external_ip" {
description = "IP pública externa"
}
variable "vcd_edge_local_ip_nginx" {}
variable "vcd_edge_local_ip_bitrix" {}
variable "vcd_edge_local_ip_nextcloud" {}
variable "vcd_edge_external_network" {}
Valores de las variables que obtenemos del proveedor.
vcd_org_user — nombre de usuario con derechos de Administrador de Organización,
vcd_org_password — contraseña del usuario,
vcd_org — nombre de la organización,
vcd_org_vdc — nombre del centro de datos virtual,
vcd_org_url — URL de la API,
vcd_org_edge_name — nombre del enrutador virtual,
vcd_org_catalog — nombre del catálogo de 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 HDD,
vcd_org_ssd_sp — nombre de la política de almacenamiento SSD.
Y definimos nuestras propias 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.
En el segundo archivo, creamos y especificamos las variables para el módulo VMware vCloud Director en el archivo vcd.tfvars: Recordemos que en nuestro ejemplo usamos , si trabaja con otro proveedor, consulte 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 = "Política de almacenamiento Oro"
vcd_org_hdd_sp = "Política de almacenamiento Bronce"
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 definidas, ahora configuraremos el esquema de conexión de las máquinas virtuales: asignaremos una dirección IP privada a cada máquina virtual y mediante NAT de destino 'redirigiremos' los puertos a la red externa. Para restringir el acceso a los puertos de gestión, estableceremos acceso solo para nuestra dirección IP.
Esquema de red para la plataforma Terraform creada
Creamos una red organizacional virtual llamada net_lan01, con una puerta de enlace predeterminada: 192.168.110.254, así como con un espacio de direcciones: 192.168.110.0/24.
Describimos la 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"
}
}
Crearemos reglas para el firewall que permitan a las máquinas virtuales acceder a Internet. Dentro de este bloque, todos los recursos virtuales en la nube tendrán acceso a la red Internet:
Describimos las reglas para que las VM accedan a Internet.
resource "vcd_nsxv_firewall_rule" "fw_internet_access" {
edge_gateway = var.vcdorgedgename
name = "Acceso a Internet"
source {
gateway_interfaces = ["internal"]
}
destination {
gateway_interfaces = ["external"]
}
service {
protocol = "any"
}
depends_on = [vcdnetworkrouted.net]
}
Al establecer la dependencia, después de procesar el bloque vcdnetworkrouted.net, comenzamos la configuración del bloque vcdnsxvfirewallrule., mediante dependson. Usamos esta opción, ya que algunas dependencias pueden no ser reconocidas implícitamente en la configuración.
A continuación, crearemos reglas que permitan el acceso a los puertos desde la red externa y especificamos nuestra dirección IP para conectarnos por SSH a los servidores. Cualquier usuario de Internet tiene acceso a los puertos 80 y 443 en el servidor web y el usuario con la dirección IP 90.1.15.1 tiene acceso a los puertos SSH de los servidores virtuales.
Permitimos el acceso a los puertos desde la red externa.
resource "vcd_nsxv_firewall_rule" "fwnatports" {
edge_gateway = var.vcd_org_edge_name
name = "Acceso HTTPs"
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 = "Acceso Admin"
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 de NAT de origen para el acceso a Internet desde la red local de la nube:
Describimos las reglas de NAT de origen.
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 al finalizar la configuración del bloque de red, añadimos reglas de NAT de destino para el acceso a los servicios desde la red externa:
Añadimos reglas 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"
dirección_original = var.vcd_edge_external_ip
puerto_original = 443
dirección_traducida = var.vcd_edge_local_ip_nginx
puerto_traducido = 443
protocolo = "tcp"
depends_on = [vcd_network_routed.net]
}
recurso "vcd_nsxv_dnat" "dnat_tcp_nginx_http" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descripción = "NGINX HTTP"
dirección_original = var.vcd_edge_external_ip
puerto_original = 80
dirección_traducida = var.vcd_edge_local_ip_nginx
puerto_traducido = 80
protocolo = "tcp"
depends_on = [vcd_network_routed.net]
}
Añadimos una regla NAT para la traducción de puertos al servidor SSH bajo Nginx.
recurso "vcd_nsxv_dnat" "dnat_tcp-nginx_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descripción = "SSH NGINX"
dirección_original = var.vcd_edge_external_ip
puerto_original = 58301
dirección_traducida = var.vcd_edge_local_ip_nginx
puerto_traducido = 22
protocolo = "tcp"
depends_on = [vcd_network_routed.net]
}
Añadimos una regla NAT para la traducción de puertos al servidor SSH con 1C-Bitrix.
recurso "vcd_nsxv_dnat" "dnat_tcp_bitrix_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descripción = "SSH Bitrix"
dirección_original = var.vcd_edge_external_ip
puerto_original = 58302
dirección_traducida = var.vcd_edge_local_ip_bitrix
puerto_traducido = 22
protocolo = "tcp"
depends_on = [vcd_network_routed.net]
}
Añadimos una regla NAT para la traducción de puertos al servidor SSH con Nextcloud.
recurso "vcd_nsxv_dnat" "dnat_tcp_nextcloud_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descripción = "SSH Nextcloud"
dirección_original = var.vcd_edge_external_ip
puerto_original = 58303 dirección_traducida = var.vcd_edge_local_ip_nextcloud
puerto_traducido = 22
protocolo = "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. Serán preparadas utilizando 'Guest Customization'. Los parámetros de red se configurarán según nuestras especificaciones, y la contraseña del usuario se generará automáticamente.
Describiremos el vApp en el que estarán las máquinas virtuales y su configuración.
Configuración de las máquinas virtuales
Crearemos un contenedor vApp. Para que podamos conectar inmediatamente el vApp y las VM a la red virtual, también añadimos el parámetro depends_on:
Creando el contenedor
recurso "vcd_vapp" "vapp" {
nombre = "web"
encender = "true" depends_on = [vcd_network_routed.net]
}
Crearemos una máquina virtual con la descripción
recurso "vcd_vapp_vm" "nginx" {
nombre_vapp = vcd_vapp.vapp.nombre
nombre = "nginx"
nombre_catalogo = var.vcd_org_catalog
nombre_plantilla = var.vcd_template_os_centos7
perfil_almacenamiento = var.vcd_org_ssd_sp
memoria = 8192
cpus = 1
núcleos_cpu = 1
red {
tipo = "org"
nombre = vcd_network_routed.net.nombre
es_primario = true
tipo_adaptador = "VMXNET3"
modo_asignación_ip = "MANUAL"
ip = var.vcd_edge_local_ip_nginx
}
sobrescribir_matriz_disco {
tipo_bus = "paravirtual"
tamaño_en_mb = "32768"
número_bus = 0
número_unidad = 0
perfil_almacenamiento = var.vcd_org_ssd_sp
}
}
Parámetros principales en la descripción de la VM:
nombre — nombre de la máquina virtual,
nombre_vapp — nombre del vApp al que agregar la nueva VM,
nombre_catalogo / nombre_plantilla — nombre del catálogo y nombre de la plantilla de la máquina virtual,
perfil_almacenamiento — política de almacenamiento por defecto.
Parámetros del bloque red:
tipo — tipo de red conectada,
nombre — a qué red virtual conectar la VM,
es_primario — adaptador de red principal,
modo_asignación_ip — modo de asignación de dirección MANUAL / DHCP / POOL,
ip — dirección IP para la máquina virtual, se especificará manualmente.
Bloque sobrescribir_matriz_disco:
tamaño_en_mb — tamaño del disco de arranque para la máquina virtual
perfil_almacenamiento — política de almacenamiento para el disco
Crearemos una segunda VM con la descripción del almacenamiento de archivos Nextcloud
recurso "vcd_vapp_vm" "nextcloud" {
nombre_vapp = vcd_vapp.vapp.nombre
nombre = "nextcloud"
nombre_catalogo = var.vcd_org_catalog
nombre_plantilla = var.vcd_template_os_centos7
perfil_almacenamiento = var.vcd_org_ssd_sp
memoria = 8192
cpus = 1
núcleos_cpu = 1
red {
tipo = "org"
nombre = vcd_network_routed.net.nombre
es_primario = true
tipo_adaptador = "VMXNET3"
modo_asignación_ip = "MANUAL"
ip = var.vcd_edge_local_ip_nextcloud
}
sobrescribir_matriz_disco {
tipo_bus = "paravirtual"
tamaño_en_mb = "32768"
número_bus = 0
número_unidad = 0
perfil_almacenamiento = var.vcd_org_ssd_sp
}
}
recurso "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 se conecta a la máquina virtual.
Explicaciones sobre el bloque vcdvminternaldisk:
bustype — tipo de controlador de disco
sizeinmb — tamaño del disco
busnumber / unitnumber — ubicación de conexión en el adaptador
perfil_almacenamiento — política de almacenamiento para el disco
Describiremos la última VM en Bitrix
recurso "vcd_vapp_vm" "bitrix" {
nombre_vapp = vcd_vapp.vapp.nombre
nombre = "bitrix"
nombre_catalogo = var.vcd_org_catalog
nombre_plantilla = var.vcd_template_os_centos7
perfil_almacenamiento = var.vcd_org_ssd_sp
memoria = 8192
cpus = 1
núcleos_cpu = 1
red {
tipo = "org"
nombre = vcd_network_routed.net.nombre
es_primario = true
tipo_adaptador = "VMXNET3"
modo_asignación_ip = "MANUAL"
ip = var.vcd_edge_local_ip_bitrix
}
sobrescribir_matriz_disco {
tipo_bus = "paravirtual"
size_in_mb = "81920"
número_bus = 0
número_unidad = 0
perfil_almacenamiento = var.vcd_org_ssd_sp
}
}
Actualización del sistema operativo e instalación de scripts adicionales
La red está preparada, las máquinas virtuales están descritas. Antes de importar nuestra infraestructura, podemos realizar el aprovisionamiento inicial mediante bloques de provisioners y sin usar Ansible.
Veamos cómo actualizar el sistema operativo y ejecutar el script de instalación del CMS Bitrix utilizando un bloque de provisioner.
Primero realizaremos la instalación de los paquetes de actualización de CentOS.
recurso "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 los componentes:
provisioner «remote-exec» — conectamos el bloque de «aprovisionamiento» remoto
En el bloque de conexión describimos el tipo y los parámetros de conexión:
type — protocolo, en nuestro caso SSH;
user — nombre de usuario;
password — contraseña del usuario. En nuestro caso, referenciamos el parámetro vcdvappvm.nginx.customization[0].admin_password, que almacena la contraseña generada del usuario del sistema.
host — dirección IP externa para la conexión;
port — puerto para la conexión, que se especificó anteriormente en la configuración de DNAT;
inline — enumeramos la lista de comandos que se introducirán. Los comandos se introducirán en el orden indicado en esta sección.
Como ejemplo, además ejecutaremos el script de instalación de 1C-Bitrix. El resultado de la ejecución del script estará disponible durante la ejecución del plan. Para instalar el script, primero describimos el bloque:
Describiremos 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"
]
}
Y de inmediato describiremos la actualización de Bitrix.
Ejemplo de aprovisionamiento de 1C-Bitrix.
recurso "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! El script puede no funcionar si no se desactiva SELinux previamente. Si necesitas un artículo detallado sobre la instalación y configuración de CMS 1C-Bitrix usando bitrix-env.sh, puedes .
3. Inicialización de la infraestructura
Inicialización de módulos y plugins
Para trabajar, utilizamos un simple 'kit de caballero': una laptop con Windows 10 y una distribución del sitio oficial . Descomprimimos y inicializamos con el comando: terraform.exe init
Después de describir la infraestructura computacional y de red, iniciamos la planificación para verificar nuestra configuración, donde podemos ver qué se creará y cómo están interconectados.
Ejecutamos el comando
- terraform plan -var-file=vcd.tfvars.Obtenemos el resultado
- Plan: 16 a agregar, 0 a cambiar, 0 a destruir.Es decir, según este plan se crearán 16 recursos.Ejecutamos el plan con el comando
- terraform.exe apply -var-file=vcd.tfvars.
Se crearán máquinas virtuales y luego se ejecutarán los paquetes que enumeramos en la sección de provisioner; el sistema operativo se actualizará e instalará el CMS Bitrix.
Obtención de datos para la conexión
Después de ejecutar el plan, queremos obtener en formato de texto los datos para conectarnos a los servidores, para ello organizaremos la sección de output de la siguiente manera:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
Y la siguiente salida nos informa la contraseña de la máquina virtual creada:
Outputs: nginx_password = F#4u8!!N
Al final, obtenemos acceso a las máquinas virtuales con un sistema operativo actualizado y paquetes preinstalados para nuestro trabajo posterior. ¡Todo listo!
Pero, ¿qué pasa si ya tienes infraestructura existente?
3.1. Trabajo de Terraform con infraestructura existente
Es simple, puedes importar las máquinas virtuales actuales y sus contenedores vApp utilizando el comando import.
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 vApp en el formato vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, donde:
vApp — nombre del vApp;
org — nombre de la organización;
org_vdc — nombre del centro de datos virtual.
Importación de propiedades del recurso vAPP
Importaremos las propiedades de los recursos VM en el formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, en el que:
VM — nombre de la VM;
vApp — nombre del vApp;
org — nombre de la organización;
orgvdc — nombre del centro de datos virtual.
La importación se completó con éxito
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importando desde ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Importación preparada!
vcd_vapp_vm preparado para importación
vcd_vapp_vm.Zabbix: Actualizando estado... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
¡Importación exitosa!
Los recursos que se importaron se muestran arriba. Estos recursos están ahora en
tu estado de Terraform y a partir de ahora serán gestionados por 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 = "asignado"
metadata = {}
nombre = "Monitoreo"
org = "mClouds"
estado = 4
status_text = "ENCENDIDO"
vdc = "mClouds"
}
…
# vcd_vapp_vm.Zabbix:
resource "vcd_vapp_vm" "Zabbix" {
nombre_computadora = "Zabbix"
núcleos_cpu = 1
cpus = 2
exponer_virtualizacion_hardware = false
guest_properties = {}
versión_hardware = "vmx-14"
href = "https://vcloud.mclouds.ru/api/vApp/vm-778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
id = "urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
disco_interno = [
{
número_bus = 0
tipo_bus = "paravirtual"
disk_id = "2000"
iops = 0
tamaño_en_mb = 122880
perfil_de almacenamiento = "Política de Almacenamiento Oro"
provisionamiento_delgado = true
número_unidad = 0
},
]
memoria = 8192
metadata = {}
nombre = "Zabbix"
org = "mClouds"
tipo_os = "centos8_64Guest"
perfil_de almacenamiento = "Política de Almacenamiento Oro"
nombre_vapp = "Monitoreo"
vdc = "mClouds"
personalización {
permitir_contraseña_admin_local = true
generar_contraseña_automática = true
cambiar_sid = false
habilitado = false
forzar = false
unirse_dominio = false
unirse_dominio_org = false
debe_cambiar_contraseña_en_primer_inicio = false
número_de_autoinicios = 0
}
red {
tipo_adaptador = "VMXNET3"
modo_asignación_ip = "DHCP"
es_primario = true
mac = "00:50:56:07:01:b1"
nombre = "MCLOUDS-LAN01"
tipo = "org"
}
}
Ahora está listo: hemos terminado con el último aspecto (importación en infraestructura existente) y hemos revisado todos los puntos clave sobre cómo trabajar con Terraform.
La herramienta resultó ser muy conveniente y permite describir su infraestructura como código, desde máquinas virtuales de un solo proveedor de nube hasta la descripción de recursos de componentes de red.
Además, la independencia del entorno permite trabajar con recursos locales y en la nube, finalizando con la gestión de la plataforma. En caso de que no haya una plataforma compatible y se quiera agregar algo nuevo, se puede escribir su propio proveedor y utilizarlo.
Fuente: habr.com
