In questo articolo esamineremo di cosa si compone Terraform e avvieremo passo dopo passo la nostra infrastruttura — prepareremo tre VM per scopi diversi: proxy, archiviazione di file e CMS.
Tutto in dettaglio e in tre fasi:
1. Terraform — descrizione, vantaggi e componenti
Terraform è uno strumento IaC (Infrastructure-as-Code) per costruire e gestire infrastrutture virtuali tramite codice.
Nell'uso dello strumento abbiamo notato diversi vantaggi:
Velocità di distribuzione di nuovi tenant (ambienti virtuali utente). Di solito, quanto più clienti nuovi ci sono, tanto più "clic" deve fare il personale di supporto tecnico per pubblicare nuove risorse. Con Terraform gli utenti possono modificare i parametri delle macchine virtuali (ad esempio, spegnere automaticamente il sistema operativo e aumentare la partizione del disco virtuale) senza l'intervento del supporto tecnico e senza spegnere la macchina stessa.
Controllo immediato del piano di attivazione di un nuovo tenant. Utilizzando la descrizione del codice dell'infrastruttura, possiamo subito verificare cosa e in quale ordine sarà aggiunto, nonché quale sarà lo stato finale di una determinata macchina virtuale o rete virtuale con le connessioni alle macchine virtuali.
Possibilità di descrivere la maggior parte delle popolari piattaforme cloud. Puoi utilizzare lo strumento da Amazon e Google Cloud, fino a piattaforme private basate su VMware vCloud Director, che offrono servizi nel contesto di soluzioni IaaS, SaaS e PaaS.
Gestire più fornitori di cloud e diffondere l'infrastruttura tra di essi per aumentare la resilienza, utilizzando una sola configurazione per creare, diagnosticare e gestire le risorse cloud.
Uso conveniente per creare stand dimostrativi per testare e debuggare il software. Puoi creare e consegnare stand per il dipartimento di test, controllando parallelamente il software in diversi ambienti, oltre a modificare e rimuovere immediatamente le risorse, creando solo un piano di costruzione delle risorse.
«Terrarium» Terraform
Abbiamo brevemente parlato dei vantaggi dello strumento, ora analizziamo i suoi componenti
Providers (fornitori).
In Terraform, praticamente qualsiasi tipo di infrastruttura può essere rappresentato come una risorsa. La connessione tra risorse e la piattaforma API è fornita dai moduli providers, che consentono di creare risorse su una determinata piattaforma, ad esempio Azure o VMware vCloud Director.
All'interno del progetto puoi interagire con diversi provider su diverse piattaforme.
Resources (descrizione delle risorse).
La descrizione delle risorse consente di gestire i componenti della piattaforma, come macchine virtuali o reti.
Puoi creare autonomamente la descrizione delle risorse per il provider VMware vCloud Director e utilizzare questa descrizione per creare risorse presso qualsiasi provider di hosting che utilizza vCloud Director. Ti basterà sostituire i parametri di autenticazione e i parametri di connessione di rete con quelli del provider di hosting necessario.
Provisioners.
Questa componente consente di eseguire operazioni di installazione iniziale e manutenzione del sistema operativo dopo la creazione delle macchine virtuali. Dopo aver creato una risorsa macchina virtuale, tramite i provisioners puoi configurarla e connetterti tramite SSH, effettuare aggiornamenti del sistema operativo e caricare ed eseguire uno script.
Variabili Input e Output.
Le variabili Input sono variabili in ingresso per qualsiasi tipo di blocco.
Le variabili Output permettono di salvare valori dopo la creazione delle risorse e possono essere utilizzate come variabili in ingresso in altri moduli, ad esempio nel blocco Provisioners.
States (stati).
I file States memorizzano informazioni sulla configurazione delle risorse della piattaforma del provider. Alla prima creazione della piattaforma non ci sono informazioni sulle risorse e prima di qualsiasi operazione Terraform aggiorna lo stato con l'infrastruttura reale delle risorse già descritte.
L'obiettivo principale degli stati è conservare il collegamento tra gli oggetti delle risorse già create per confrontare la configurazione delle risorse aggiunte e degli oggetti, per evitare creazioni e modifiche ripetute della piattaforma.
Per impostazione predefinita, le informazioni sullo stato vengono memorizzate in un file locale terraform.tfstate, ma se necessario è possibile utilizzare un'archiviazione remota per lavorare in team.
Puoi anche importare le risorse attuali della piattaforma nello stato, per interagire successivamente con altre risorse che sono state create senza l'aiuto di Terraform.
2. Creazione dell'infrastruttura
Abbiamo analizzato i componenti, ora con Terraform creeremo passo dopo passo un'infrastruttura con tre macchine virtuali. La prima avrà un server proxy nginx installato, la seconda un'archiviazione file basata su Nextcloud e la terza un CMS Bitrix.
Scriveremo codice ed eseguiremo esempi con il nostro . Gli utenti ottengono un'email con diritti di Organization Administrator; se usi un'email con gli stessi diritti in un altro cloud VMware, potrai replicare il codice dai nostri esempi. Andiamo!
Iniziamo creando una directory per il nostro nuovo progetto, in cui verranno posizionati i file per la descrizione dell'infrastruttura.
mkdir project01
Poi descriveremo i componenti dell'infrastruttura. Terraform crea collegamenti e gestisce i file basandosi sulla loro descrizione. I file possono essere nominati in base all'utilizzo previsto dei blocchi descritti, ad esempio, network.tf — descrive i parametri di rete per l'infrastruttura.
Per descrivere i componenti della nostra infrastruttura, abbiamo creato i seguenti file:
Elenco dei file.
main.tf — descrizione dei parametri per l'ambiente virtuale — macchine virtuali, contenitori virtuali;
network.tf — descrizione dei parametri della rete virtuale e regole NAT, Firewall;
variables.tf — elenco delle variabili che utilizziamo;
vcd.tfvars — valori delle variabili del progetto per il modulo VMware vCloud Director.
Il linguaggio di configurazione in Terraform è dichiarativo e l'ordine dei blocchi non ha importanza, tranne per i blocchi provisioner, poiché in questo blocco descriviamo i comandi da eseguire durante la preparazione dell'infrastruttura e verranno eseguiti in sequenza.
Struttura dei blocchi.
"" "" {
# Block body
= # Argomento
}
Per descrivere i blocchi si utilizza un proprio linguaggio di programmazione HCL (HashiCorp Configuration Language); è possibile descrivere l'infrastruttura anche utilizzando JSON. Maggiori dettagli sulla sintassi possono essere .
Configurazione della variabile ambiente, variables.tf e vcd.tfvars
Iniziamo creando due file che descrivono l'elenco di tutte le variabili utilizzate e i loro valori per il modulo VMware vCloud Director. Creeremo prima il file variables.tf.
Contenuto del file variables.tf.
variabile "vcd_org_user" {
descrizione = "Utente del tenant vCD"
}
variabile "vcd_org_password" {
descrizione = "Password del tenant vCD"
}
variabile "vcd_org" {
descrizione = "Organizzazione del tenant vCD"
}
variabile "vcd_org_vdc" {
descrizione = "VDC del tenant vCD"
}
variabile "vcd_org_url" {
descrizione = "URL del tenant vCD"
}
variabile "vcd_org_max_retry_timeout" {
default = "60"
}
variabile "vcd_org_allow_unverified_ssl" {
default = "true"
}
variabile "vcd_org_edge_name" {
descrizione = "Nome dell'edge vCD"
}
variabile "vcd_org_catalog" {
descrizione = "Catalogo pubblico vCD"
}
variabile "vcd_template_os_centos7" {
descrizione = "Sistema operativo CentOS 7"
default = "CentOS7"
}
variabile "vcd_org_ssd_sp" {
descrizione = "Politiche di archiviazione"
default = "Politica di archiviazione Gold"
}
variabile "vcd_org_hdd_sp" {
descrizione = "Politiche di archiviazione"
default = "Politica di archiviazione Bronze"
}
variabile "vcd_edge_local_subnet" {
descrizione = "Subnet di rete dell'Organizzazione"
}
variabile "vcd_edge_external_ip" {
descrizione = "IP pubblico esterno"
}
variabile "vcd_edge_local_ip_nginx" {}
variabile "vcd_edge_local_ip_bitrix" {}
variabile "vcd_edge_local_ip_nextcloud" {}
variabile "vcd_edge_external_network" {}
Valori delle variabili forniti dal provider.
vcd_org_user — nome utente con diritti di Amministratore dell'Organizzazione,
vcd_org_password — password dell'utente,
vcd_org — nome dell'organizzazione,
vcd_org_vdc — nome del centro di dati virtuale,
vcd_org_url — URL API,
vcd_org_edge_name — nome del router virtuale,
vcd_org_catalog — nome del catalogo con i template delle macchine virtuali,
vcd_edge_external_ip — indirizzo IP pubblico,
vcd_edge_external_network — nome della rete esterna,
vcd_org_hdd_sp — nome della politica di archiviazione HDD,
vcd_org_ssd_sp — nome della politica di archiviazione SSD.
E inseriamo le nostre variabili:
vcd_edge_local_ip_nginx — indirizzo IP della macchina virtuale con NGINX,
vcd_edge_local_ip_bitrix — indirizzo IP della macchina virtuale con 1C: Bitrix,
vcd_edge_local_ip_nextcloud — indirizzo IP della macchina virtuale con Nextcloud.
Con il secondo file creiamo e indichiamo le variabili per il modulo VMware vCloud Director nel file vcd.tfvars: Ricordiamo che nel nostro esempio usiamo , se stai lavorando con un altro fornitore chiarisci i valori con lui.
Contenuto del file 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 = "Politica di archiviazione Gold"
vcd_org_hdd_sp = "Politica di archiviazione Bronze"
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"
Configurazione di rete, network.tf.
Le variabili ambientali sono impostate, ora configuriamo lo schema di connessione delle macchine virtuali: assegneremo un indirizzo IP privato a ciascuna macchina virtuale e mediante Destination NAT "apriamo" le porte alla rete esterna. Per limitare l'accesso alle porte di gestione, autorizzeremo solo il nostro indirizzo IP.
Schema di rete per la piattaforma Terraform in fase di creazione
Creiamo una rete organizzativa virtuale chiamata net_lan01, con un gateway predefinito: 192.168.110.254, e uno spazio degli indirizzi: 192.168.110.0/24.
Descriviamo la rete virtuale.
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"
}
}
Creiamo regole per il firewall che consentono di fornire alle macchine virtuali l'accesso a Internet. All'interno di questo blocco, tutte le risorse virtuali nel cloud avranno accesso a Internet:
Descriviamo le regole per l'accesso delle VM a Internet.
resource "vcd_nsxv_firewall_rule" "fw_internet_access" {
edge_gateway = var.vcdorgedgename
name = "Accesso a Internet"
source {
gateway_interfaces = ["internal"]
}
destination {
gateway_interfaces = ["external"]
}
service {
protocol = "any"
}
depends_on = [vcdnetworkrouted.net]
}
Stabilendo la dipendenza, dopo la lavorazione del blocco vcdnetworkrouted.net procederemo alla configurazione del blocco vcdnsxvfirewallrule, tramite dependson. Utilizziamo questa opzione poiché alcune dipendenze potrebbero essere riconosciute implicitamente nella configurazione.
Successivamente, creiamo regole per consentire l'accesso alle porte dalla rete esterna e indichiamo il nostro indirizzo IP per la connessione SSH ai server. Qualsiasi utente della rete Internet avrà accesso alle porte 80 e 443 sul server web e un utente con l'indirizzo IP 90.1.15.1 avrà accesso alle porte SSH dei server virtuali.
Consentiamo l'accesso alle porte dalla rete esterna.
resource "vcd_nsxv_firewall_rule" "fwnatports" {
edge_gateway = var.vcd_org_edge_name
name = "Accesso 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 = "Accesso Amministrativo"
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]
}
Creiamo regole Source NAT per l'accesso a Internet dalla rete locale cloud:
Descriviamo le regole 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 alla fine della configurazione del blocco di rete aggiungiamo regole Destination NAT per l'accesso ai servizi dalla rete esterna:
Aggiungiamo regole Destination NAT.
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]
}
Aggiungiamo una regola NAT per la traduzione delle porte verso il server SSH dietro 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]
}
Aggiungiamo una regola NAT per la traduzione delle porte verso il server 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]
}
Aggiungiamo una regola NAT per la traduzione delle porte verso il server 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]
}
Configurazione dell'ambiente virtuale main.tf
Come programmato all'inizio dell'articolo, creeremo tre macchine virtuali. Saranno preparate con 'Guest Customization'. Imposteremo i parametri di rete secondo le configurazioni specificate e la password dell'utente verrà generata automaticamente.
Descriviamo il vApp in cui si trovano le macchine virtuali e la loro configurazione.
Configurazione delle macchine virtuali
Creiamo un contenitore vApp. Per poter collegare immediatamente il vApp e le VM alla rete virtuale, aggiungiamo anche il parametro depends_on:
Creiamo un contenitore
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Creiamo una macchina virtuale con descrizione
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
}
}
I parametri principali nella descrizione della VM:
name — nome della macchina virtuale,
vappname — nome del vApp in cui aggiungere la nuova VM,
catalogname / templatename — nome del catalogo e nome del modello della macchina virtuale,
storageprofile — politica di archiviazione predefinita.
Parametri del blocco network:
type — tipo di rete a cui connettere,
name — a quale rete virtuale connettere la VM,
isprimary — adattatore di rete principale,
ipallocation_mode — modalità di assegnazione dell'indirizzo MANUAL / DHCP / POOL,
ip — indirizzo IP per la macchina virtuale, specificato manualmente.
Blocco override_template_disk:
sizeinmb — dimensione del disco di avvio per la macchina virtuale
storage_profile — politica di archiviazione per il disco
Creiamo una seconda VM con descrizione dello storage di 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
}
}
risorsa "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 ]
}
Nella sezione vcdvminternal_disk descriviamo un nuovo disco virtuale che si collega alla macchina virtuale.
Spiegazioni sul blocco vcdvminternaldisk:
bustype — tipo di controller del disco
sizeinmb — dimensione del disco
busnumber / unitnumber — posizione di connessione nell'adattatore
storage_profile — politica di archiviazione per il disco
Descriviamo l'ultima VM su Bitrix
risorsa "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
}
}
Aggiornamento del sistema operativo e installazione di script aggiuntivi
La rete è stata preparata, le macchine virtuali sono state descritte. Prima di importare la nostra infrastruttura, possiamo eseguire in anticipo il provisioning iniziale utilizzando i blocchi dei provisioners e senza l'uso di Ansible.
Vediamo come aggiornare il sistema operativo e avviare lo script di installazione del CMS Bitrix tramite il blocco dei provisioner.
Per prima cosa, eseguiamo l'installazione dei pacchetti di aggiornamento di CentOS.
risorsa "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" ]
}
}
}
Designazione dei componenti:
provisioner «remote-exec» — collegamento del blocco di provisioning remoto
Nel blocco connection descriviamo il tipo e i parametri per la connessione:
type — protocollo, in questo caso SSH;
user — nome utente;
password — password dell'utente. In questo caso facciamo riferimento al parametro vcdvappvm.nginx.customization[0].admin_password, che contiene la password generata per l'utente del sistema.
host — indirizzo IP esterno per la connessione;
port — porta per la connessione, precedentemente specificata nelle impostazioni DNAT;
inline — elenchiamo l'elenco dei comandi che verranno inseriti. I comandi verranno eseguiti nell'ordine in cui sono indicati in questa sezione.
Come esempio, eseguiamo anche lo script di installazione di 1C-Bitrix. L'output del risultato dell'esecuzione dello script sarà disponibile durante l'esecuzione del piano. Per installare lo script, iniziamo col descrivere il blocco:
Descriviamo l'installazione di 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 subito descriviamo l'aggiornamento di Bitrix.
Esempio di provisioning 1C-Bitrix.
risorsa "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! Lo script potrebbe non funzionare se non si disattiva in anticipo SELinux! Se hai bisogno di un articolo dettagliato sull'installazione e la configurazione di CMS 1C-Bitrix utilizzando bitrix-env.sh, puoi .
3. Inizializzazione dell'infrastruttura
Inizializzazione dei moduli e dei plugin
Per il lavoro utilizziamo un semplice "set da gentiluomo": un laptop con sistema operativo Windows 10 e una distribuzione dal sito ufficiale . Estraiamo e inizializziamo utilizzando il comando: terraform.exe init
Dopo aver descritto l'infrastruttura di elaborazione e di rete, avviamo la pianificazione per verificare la nostra configurazione, dove possiamo vedere cosa verrà creato e come sarà interconnesso.
Eseguiamo il comando
- terraform plan -var-file=vcd.tfvars.Riceviamo il risultato
- Piano: 16 da aggiungere, 0 da cambiare, 0 da distruggere.In altre parole, secondo questo piano, verranno creatte 16 risorse.Avviamo il piano con il comando
- terraform.exe apply -var-file=vcd.tfvars.
Le macchine virtuali saranno create e i pacchetti elencati nella sezione provisioner verranno eseguiti — il sistema operativo sarà aggiornato e verrà installato CMS Bitrix.
Ottenere i dati di connessione
Dopo aver eseguito il piano, vogliamo ottenere in formato testuale i dati per connettersi ai server; per questo formatteremo la sezione output come segue:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
E la seguente uscita ci comunica la password per la macchina virtuale creata:
Outputs: nginx_password = F#4u8!!N
In definitiva, otteniamo l'accesso alle macchine virtuali con sistema operativo aggiornato e pacchetti preinstallati per il nostro lavoro successivo. Tutto pronto!
Ma cosa fare se hai già un'infrastruttura esistente?
3.1. Lavorare con Terraform su un'infrastruttura esistente
È semplice, puoi importare le macchine virtuali attuali e i loro contenitori vApp utilizzando il comando import.
Descriviamo la risorsa vAPP e la macchina virtuale.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
Il passo successivo è importare le proprietà delle risorse vApp nel formato vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, dove:
vApp — nome vApp;
org — nome dell'organizzazione;
org_vdc — nome del data center virtuale.
Importazione delle proprietà della risorsa vAPP
Eseguiamo l'importazione delle proprietà delle risorse VM nel formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, in cui:
VM — nome della VM;
vApp — nome vApp;
org — nome dell'organizzazione;
orgvdc — nome del data center virtuale.
Importazione completata con successo
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importazione da ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Importazione pronta!
vcd_vapp_vm preparato per l'importazione
vcd_vapp_vm.Zabbix: Aggiornamento stato... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Importazione riuscita!
Le risorse importate sono indicate sopra. Queste risorse sono ora nel
tuo stato Terraform e saranno gestite da Terraform d'ora in poi.
Ora possiamo osservare la nuova risorsa importata:
Risorsa importata
> 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 = "assegnato"
metadata = {}
name = "Monitoring"
org = "mClouds"
status = 4
status_text = "ACCESO"
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 = "Politica di archiviazione Gold"
thin_provisioned = true
unit_number = 0
},
]
memory = 8192
metadata = {}
name = "Zabbix"
org = "mClouds"
os_type = "centos8_64Guest"
storage_profile = "Politica di archiviazione Gold"
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"
}
}
Ora è tutto pronto — abbiamo concluso con l'ultimo punto (importazione nell'infrastruttura esistente) e abbiamo esaminato tutti i principali aspetti del lavoro con Terraform.
Lo strumento si è rivelato molto utile e consente di descrivere la tua infrastruttura come codice, iniziando dalle macchine virtuali di un provider cloud fino alla descrizione delle risorse dei componenti di rete.
In questo modo, l'indipendenza dall'ambiente consente di lavorare sia con le risorse locali che con quelle cloud, e per quanto riguarda la gestione della piattaforma. In assenza di una piattaforma supportata e nel desiderio di aggiungere una nuova, è possibile scrivere il proprio provider e utilizzarlo.
Fonte: habr.com
