In questo articolo esamineremo cos'è Terraform e avvieremo passo dopo passo la nostra infrastruttura — prepareremo tre VM per scopi diversi: proxy, archiviazione file e CMS.
Tutti i dettagli in tre fasi:
1. Terraform — descrizione, vantaggi e componenti
Terraform è uno strumento IaC (Infrastructure-as-Code) per costruire e gestire infrastrutture virtuali tramite codice.
Negli utilizzi dello strumento, abbiamo notato diversi vantaggi:
Rapidità di distribuzione di nuovi tenant (ambienti virtuali per utenti). Di solito, più clienti ci sono, più „clic“ i dipendenti del supporto tecnico devono fare per pubblicare nuove risorse. Con Terraform, gli utenti possono modificare le impostazioni 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.
Verifica istantanea del piano di attivazione nuovo tenant. Con la descrizione del codice infrastrutturale, possiamo subito verificare cosa e in quale ordine verrà aggiunto, oltre allo stato finale di una certa macchina virtuale o rete virtuale connessa a macchine virtuali.
La possibilità di descrivere la maggior parte delle piattaforme cloud popolari. Puoi utilizzare lo strumento da Amazon e Google Cloud a piattaforme private basate su VMware vCloud Director, che offrono servizi nell'ambito delle soluzioni IaaS, SaaS e PaaS.
Gestire più fornitori di cloud e distribuire l'infrastruttura tra di essi per aumentare l'affidabilità, utilizzando una sola configurazione per la creazione, diagnosi e gestione delle risorse cloud.
Facile utilizzo per la creazione di stand dimostrativi per il test e il debugging del software. Puoi creare e trasferire stand per il dipartimento di testing, verificare parallelamente il software in ambienti diversi e modificare e rimuovere immediatamente risorse con un unico piano di costruzione delle risorse.
«Terrarium» Terraform
Abbiamo brevemente discusso dei vantaggi dello strumento, ora analizziamolo nelle sue componenti.
Fornitori.
In Terraform, praticamente ogni tipo di infrastruttura può essere rappresentato come una risorsa. La connessione tra le risorse e la piattaforma API è garantita dai moduli provider, che consentono di creare risorse all'interno di una piattaforma specifica, come Azure o VMware vCloud Director.
All'interno del progetto, puoi interagire con diversi fornitori su diverse piattaforme.
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 fornitore VMware vCloud Director e utilizzare questa descrizione per creare risorse presso qualsiasi fornitore di hosting che utilizzi vCloud Director. Dovrai solo sostituire i parametri di autenticazione e i parametri di connessione di rete con quelli necessari per il fornitore di hosting scelto.
Provisioner.
Questo componente consente di eseguire operazioni di installazione e manutenzione iniziale del sistema operativo dopo la creazione delle macchine virtuali. Dopo aver creato la risorsa della macchina virtuale, tramite i provisioner puoi configurare e connetterti tramite SSH, eseguire un aggiornamento del sistema operativo e caricare ed eseguire uno script.
Variabili Input e Output.
Le variabili di input sono variabili di ingresso per qualsiasi tipo di blocco.
Le variabili di output consentono di salvare i valori dopo la creazione delle risorse e possono essere utilizzate come variabili di input in altri moduli, ad esempio nel blocco dei Provisioners.
Stati.
I file di stato memorizzano le informazioni sulla configurazione delle risorse della piattaforma del provider. Al momento della 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 è preservare il legame degli oggetti delle risorse già create per confrontare la configurazione delle risorse aggiunte e degli oggetti, evitando così la ricreazione e le modifiche della piattaforma.
Le informazioni di stato predefinite vengono memorizzate in un file locale terraform.tfstate, ma è possibile utilizzare uno storage remoto per la collaborazione in team, se necessario.
Inoltre, puoi importare le risorse attuali della piattaforma nello stato, per poter interagire successivamente con altre risorse che sono state create senza l'ausilio di Terraform.
2. Creazione dell'infrastruttura
Abbiamo analizzato i componenti, ora con Terraform creiamo passo dopo passo un'infrastruttura con tre macchine virtuali. La prima avrà un server proxy nginx installato, la seconda sarà uno storage file basato su Nextcloud e la terza con CMS Bitrix.
Scriveremo codice ed eseguiremo esempi sul nostro . Gli utenti ricevono un'account con diritti di Organization Administrator; se utilizzi un'account con gli stessi diritti in un altro cloud VMware, potrai riprodurre il codice dai nostri esempi. Andiamo!
Cominciamo creando una directory per il nostro nuovo progetto, dove verranno posizionati i file di descrizione dell'infrastruttura.
mkdir project01
Successivamente descriveremo i componenti dell'infrastruttura. Terraform crea collegamenti e gestisce i file in base alla descrizione nei file. I file possono essere nominati in base allo scopo 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, container virtuali;
network.tf — descrizione dei parametri della rete virtuale e delle regole NAT, Firewall;
variables.tf — elenco delle variabili che utilizziamo;
vcd.tfvars — valori delle variabili di progetto per il modulo VMware vCloud Director.
Il linguaggio di configurazione di Terraform è dichiarativo e l'ordine dei blocchi non ha importanza, eccezion fatta per i blocchi provisioner, poiché in questo blocco descriviamo i comandi da eseguire durante la preparazione dell'infrastruttura e verranno eseguiti in ordine.
Struttura dei blocchi.
"" "" {
# Block body
= # Argomento
}
Per descrivere i blocchi si utilizza un linguaggio di programmazione proprietario HCL (HashiCorp Configuration Language), è possibile descrivere l'infrastruttura anche utilizzando JSON. Maggiori informazioni sulla sintassi possono .
Configurazione della variabile ambientale, 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. Creiamo 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" {
predefinito = "60"
}
variabile "vcd_org_allow_unverified_ssl" {
predefinito = "true"
}
variabile "vcd_org_edge_name" {
descrizione = "Nome del edge vCD"
}
variabile "vcd_org_catalog" {
descrizione = "Catalogo pubblico vCD"
}
variabile "vcd_template_os_centos7" {
descrizione = "OS CentOS 7"
predefinito = "CentOS7"
}
variabile "vcd_org_ssd_sp" {
descrizione = "Politiche di Archiviazione"
predefinito = "Politica di Archiviazione Gold"
}
variabile "vcd_org_hdd_sp" {
descrizione = "Politiche di Archiviazione"
predefinito = "Politica di Archiviazione Bronze"
}
variabile "vcd_edge_local_subnet" {
descrizione = "Subnet della 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 che otteniamo dal fornitore.
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 data center virtuale,
vcd_org_url — URL API,
vcd_org_edge_name — nome del router virtuale,
vcd_org_catalog — nome del catalogo con i modelli 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 utilizziamo , se stai lavorando con un altro fornitore, verifica 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 Oro"
vcd_org_hdd_sp = "Politica di Archiviazione Bronzo"
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 configureremo lo schema di connessione delle macchine virtuali: a ciascuna macchina virtuale verrà assegnato un indirizzo IP privato e, tramite Destination NAT, apriamo le porte sulla rete esterna. Per limitare l'accesso alle porte di gestione, consentiremo l'accesso solo al nostro indirizzo IP.
Schema di rete per la piattaforma Terraform creata
Creiamo una rete organizzativa virtuale chiamata net_lan01, con un gateway predefinito: 192.168.110.254, e uno spazio 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 alle macchine virtuali di accedere a Internet. In 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 = ["interno"]
}
destination {
gateway_interfaces = ["esterno"]
}
service {
protocol = "qualsiasi"
}
depends_on = [vcdnetworkrouted.net]
}
Stabilita la dipendenza, così dopo aver elaborato il blocco vcdnetworkrouted.net iniziamo la configurazione del blocco vcdnsxvfirewallrule, utilizzando dependson. Utilizziamo questa opzione poiché alcune dipendenze possono essere riconosciute implicitamente nella configurazione.
Successivamente, creiamo regole che consentono l'accesso alle porte dalla rete esterna e indichiamo il nostro indirizzo IP per connetterci via SSH ai server. Qualsiasi utente della rete Internet ha accesso alle porte 80 e 443 sul server web e l'utente con l'indirizzo IP 90.1.15.1 ha 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 = ["esterno"]
}
destination {
gateway_interfaces = ["interno"]
}
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 Admin"
source {
ip_addresses = [ "90.1.15.1" ]
}
destination {
gateway_interfaces = ["interno"]
}
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 alla rete 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]
}
Infine, nella configurazione del blocco di rete, aggiungiamo le regole Destination NAT per accedere 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 al server SSH sotto 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 al 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 al 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 pianificato all'inizio dell'articolo, creeremo tre macchine virtuali. Saranno preparate con "Guest Customization". I parametri di rete saranno impostati secondo le nostre specifiche, e la password dell'utente sarà generata automaticamente.
Descriviamo un vApp in cui si trovano 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
}
}
Parametri principali nella descrizione della VM:
name — nome della macchina virtuale,
vappname — nome del vApp a 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 collegare,
name — quale rete virtuale collegare alla VM,
isprimary — adattatore di rete principale,
ipallocation_mode — modalità di assegnazione dell'indirizzo MANUAL / DHCP / POOL,
ip — indirizzo IP per la macchina virtuale, verrà specificato manualmente.
Blocco override_template_disk:
sizeinmb — dimensione del disco di avvio per la macchina virtuale
storage_profile — politica di storage per il disco
Creeremo una seconda VM con la descrizione dello storage file 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
}
}
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 ]
}
Nella sezione vcdvminternal_disk descriveremo un nuovo disco virtuale, che viene collegato 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 storage per il disco
Descriveremo l'ultima VM su 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
}
}
Aggiornamento del sistema operativo e installazione di script aggiuntivi
La rete è pronta, le macchine virtuali sono descritte. Prima di importare la nostra infrastruttura, possiamo eseguire in anticipo il provisioning iniziale tramite i blocchi provisioners e senza utilizzare Ansible.
Vediamo come aggiornare il sistema operativo e avviare lo script di installazione del CMS Bitrix tramite un blocco provisioner.
Iniziamo installando i pacchetti di aggiornamento di 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" ]
}
}
}
Descrizione dei componenti:
provisioner «remote-exec» — colleghiamo il blocco di provisioning remoto.
Nel blocco connection descriviamo il tipo e i parametri per la connessione:
type — protocollo, nel nostro caso SSH;
user — nome utente;
password — password dell'utente. In questo caso utilizziamo il parametro vcdvappvm.nginx.customization[0].admin_password, che memorizza la password generata per l'utente di sistema.
host — indirizzo IP esterno per la connessione;
port — porta per la connessione, che avevamo precedentemente specificato nelle impostazioni DNAT;
inline — elenchiamo la lista dei comandi che verranno inseriti. I comandi verranno eseguiti in ordine, come indicato 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, prima descriviamo 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 descriveremo subito l'aggiornamento di Bitrix.
Esempio di provisioning 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! Lo script potrebbe non funzionare se SELinux non è disattivato in anticipo! Se hai bisogno di un articolo dettagliato su come installare e configurare CMS 1C-Bitrix utilizzando bitrix-env.sh, puoi .
3. Inizializzazione dell'infrastruttura
Inizializzazione di moduli e plugin
Per il lavoro utilizziamo un semplice "gentleman’s set": un laptop con sistema operativo Windows 10 e il pacchetto dal sito ufficiale . Decomprimi e inizializza usando il comando: terraform.exe init
Dopo aver descritto l'infrastruttura di calcolo e di rete, eseguiamo la pianificazione per controllare la nostra configurazione, dove possiamo vedere cosa verrà creato e come sarà collegato.
Eseguiamo il comando
- terraform plan -var-file=vcd.tfvars.Otteniamo il risultato
- Plan: 16 da aggiungere, 0 da modificare, 0 da distruggere.In altre parole, secondo questo piano, verranno creati 16 risorse.Avviamo il piano tramite il comando
- terraform.exe apply -var-file=vcd.tfvars.
Le macchine virtuali verranno create, e successivamente verranno eseguiti i pacchetti elencati nella sezione provisioner — il sistema operativo verrà aggiornato e verrà installato il CMS Bitrix.
Ottenere i dati per la connessione
Dopo l'esecuzione del piano, desideriamo ricevere in formato testuale i dati per la connessione ai server, pertanto organizziamo la sezione output nel seguente modo:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
E l'output seguente ci comunica la password della macchina virtuale creata:
Outputs: nginx_password = F#4u8!!N
Di conseguenza, abbiamo accesso alle macchine virtuali con un sistema operativo aggiornato e pacchetti preinstallati per il nostro ulteriore lavoro. Tutto è pronto!
Ma cosa succede se hai già un'infrastruttura esistente?
3.1. Lavorare con Terraform su un'infrastruttura già 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 del vApp;
org — nome dell'organizzazione;
org_vdc — nome del data center virtuale.
Importa le proprietà della risorsa vAPP
Procederemo con l'importazione delle proprietà delle risorse VM nel formato: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, in cui:
VM — nome della VM;
vApp — nome del 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: Importando da ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Importazione preparata!
Preparato vcd_vapp_vm per l'importazione
vcd_vapp_vm.Zabbix: Aggiornamento dello stato... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Importazione riuscita!
Le risorse che sono state importate sono mostrate sopra. Queste risorse ora sono nel
tuo stato Terraform e saranno gestite da Terraform d'ora in poi.
Ora possiamo vedere 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 = "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"
disco_interno = [
{
bus_number = 0
bus_type = "paravirtual"
id_disco = "2000"
iops = 0
dimensione_mb = 122880
profilo_di_archiviazione = "Politica di Archiviazione Gold"
provisionato_sottile = true
unit_number = 0
},
]
memoria = 8192
metadati = {}
nome = "Zabbix"
org = "mClouds"
tipo_os = "centos8_64Guest"
profilo_di_archiviazione = "Politica di Archiviazione Gold"
nome_vapp = "Monitoring"
vdc = "mClouds"
personalizzazione {
permetti_password_admin_locale = true
genera_password_automatica = true
cambia_sid = false
abilitato = false
forza = false
unisciti_dominio = false
unisciti_dominio_org = false
devi_cambiare_password_al_primo_accesso = false
numero_di_accessi_automatici = 0
}
network {
tipo_adattatore = "VMXNET3"
modo_allocazione_ip = "DHCP"
è_primario = true
mac = "00:50:56:07:01:b1"
nome = "MCLOUDS-LAN01"
tipo = "org"
}
}
Ora è tutto pronto — abbiamo terminato con l'ultimo aspetto (importazione nell'infrastruttura esistente) e abbiamo rivisto tutti i punti principali per lavorare con Terraform.
Strumento molto comodo che permette di descrivere la tua infrastruttura come codice, dalle macchine virtuali di un singolo fornitore di cloud fino alla descrizione delle risorse dei componenti di rete.
In questo modo, l'indipendenza dall'ambiente consente di lavorare sia con risorse locali che cloud, fino alla gestione della piattaforma. In assenza di una piattaforma supportata e desiderando aggiungerne una nuova, è possibile scrivere il proprio fornitore e utilizzarlo.
Fonte: habr.com
