În acest articol, vom examina din ce este compus Terraform și vom lansa pas cu pas propria infrastructură — va pregăti trei VM-uri pentru scopuri diferite: proxy, stocare de fișiere și CMS.
Despre toate în detaliu și în trei etape:
1. Terraform — descriere, avantaje și componente
Terraform este un instrument IaC (Infrastructure-as-Code) pentru construirea și gestionarea infrastructurii virtuale prin cod.
În utilizarea acestui instrument, am observat câteva avantaje:
Viteza de desfășurare a noilor clienți (medii virtuale personalizate). De obicei, cu cât sunt mai mulți clienți noi, cu atât mai multe „click-uri” trebuie să facă angajații suportului tehnic pentru a publica noi resurse. Folosind Terraform, utilizatorii pot modifica parametrii mașinilor virtuale (de exemplu, pot opri automat sistemul de operare și pot extinde partiția discului virtual) fără a necesita suport tehnic și oprirea efectivă a mașinii.
Verificarea instantanee a planului de activare al noului client. Cu ajutorul descrierii codului infrastructurii, putem verifica imediat ce și în ce ordine va fi adăugat, precum și în ce stare finală va fi o anumită mașină virtuală sau o rețea virtuală conectată la mașinile virtuale.
Posibilitatea de a descrie majoritatea platformelor cloud populare. Puteți utiliza instrumentul de la Amazon și Google Cloud, până la platforme private bazate pe VMware vCloud Director, care oferă servicii în cadrul soluțiilor IaaS, SaaS și PaaS.
Gestionarea mai multor furnizori cloud și distribuirea infrastructurii între aceștia pentru a crește reziliența, folosind o singură configurație pentru a crea, diagnostica și gestiona resursele cloud.
Utilizare convenabilă pentru crearea demo-standurilor pentru testarea și depanarea software-ului. Puteți crea și transfera standuri pentru departamentul de testare, verifica simultan software-ul în medii diferite și, de asemenea, modifica și șterge instantaneu resursele, creând doar un singur plan de construcție a resurselor
„Terarium” Terraform
Am menționat pe scurt avantajele instrumentului, acum să discutăm componentele sale
Providers (furnizori).
În Terraform, aproape orice tip de infrastructură poate fi reprezentat ca un resursă. Legătura între resurse și API-ul platformei este asigurată de modulele providers care permit crearea de resurse în cadrul unei platforme specifice, cum ar fi Azure sau VMware vCloud Director.
În cadrul proiectului, puteți interacționa cu diferiți furnizori pe diferite platforme.
Resources (descrierea resurselor).
Descrierea resurselor permite gestionarea componentelor platformei, cum ar fi mașinile virtuale sau rețelele.
Puteți crea singur o descriere a resurselor pentru furnizorul VMware vCloud Director și utiliza această descriere pentru a crea resurse la orice furnizor de hosting care utilizează vCloud Director. Va trebui doar să înlocuiți parametrii de autentificare și parametrii de conectare la rețea pentru furnizorul de hosting necesar.
Provisioners.
Această componentă permite efectuarea operațiunilor de instalare inițială și întreținere a sistemului de operare după crearea mașinilor virtuale. După ce ați creat resursa unei mașini virtuale, cu ajutorul provisioners puteți configura și conecta prin SSH, efectua actualizări ale sistemului de operare și încărca și executa un script.
Variabilele Input și Output.
Variabilele Input sunt variabilele de intrare pentru orice tipuri de blocuri.
Variabilele Output permit salvarea valorilor după crearea resurselor și pot fi utilizate ca variabile de intrare în alte module, cum ar fi blocul Provisioners.
States (stări).
Fișierele States stochează informații despre configurația resurselor platformei furnizorului. La prima creare a platformei, nu există informații despre resurse, iar înainte de orice operație Terraform actualizează starea cu infrastructura reală a resurselor deja descrise.
Scopul principal al stărilor este de a salva legătura obiectelor deja create pentru a compara configurația resurselor adăugate și a obiectelor, pentru a evita recrearea și modificările platformei.
Informațiile despre stare sunt, în mod implicit, stocate într-un fișier local terraform.tfstate, dar, dacă este necesar, există posibilitatea de a utiliza stocarea la distanță pentru a lucra în echipă.
De asemenea, puteți importa resursele curente ale platformei într-o stare pentru a interacționa ulterior cu alte resurse care, la rândul lor, au fost create fără ajutorul Terraform.
2. Crearea infrastructurii
Componentele au fost discutate, acum folosind Terraform, vom crea pas cu pas infrastructura cu trei mașini virtuale. Prima va avea un server proxy nginx instalat, a doua va avea un spațiu de stocare pe baza Nextcloud și a treia va avea CMS Bitrix.
Vom scrie cod și îl vom executa folosind exemplul nostru Utilizatorii noștri primesc un cont cu drepturi de Administrator al Organizației, dacă folosiți un cont cu aceleași drepturi într-un alt cloud VMware, veți putea reproduce codul din exemplele noastre. Să începem!
Mai întâi, vom crea un director pentru noul nostru proiect, în care vor fi plasate fișierele cu descrierea infrastructurii.
mkdir project01
Apoi vom descrie componentele infrastructurii. Terraform creează conexiuni și prelucrează fișierele pe baza descrierii din fișiere. Fișierele în sine pot fi denumite în funcție de destinația block-urilor descrise, de exemplu, network.tf - descrie parametrii rețelei pentru infrastructură.
Pentru a descrie componentele infrastructurii noastre, am creat următoarele fișiere:
Lista fișierelor.
main.tf - descrierea parametrelor pentru mediul virtual - mașini virtuale, containere virtuale;
network.tf - descrierea parametrilor rețelei virtuale și a regulilor NAT, Firewall;
variables.tf - lista variabilelor pe care le folosim;
vcd.tfvars - valorile variabilelor proiectului pentru modulul VMware vCloud Director.
Limbajul de configurare în Terraform este declarativ, iar ordinea block-urilor nu are importanță, cu excepția block-ului provisioner, deoarece în acest block descriem comenzile pentru executarea în pregătirea infrastructurii și acestea vor fi executate în ordine.
Structura block-urilor.
"" "" {
# Block body
= # Argument
}
Pentru descrierea block-urilor se folosește propriul limbaj de programare HCL (HashiCorp Configuration Language), este posibilă descrierea infrastructurii și cu ajutorul JSON. Mai multe despre sintaxă puteți .
Configurația variabilei de mediu, variables.tf și vcd.tfvars
Mai întâi vom crea două fișiere care descriu lista tuturor variabilelor utilizate și valorile lor pentru modulul VMware vCloud Director. Primul va fi fișierul variables.tf.
Conținutul fișierului variables.tf.
variabilă "vcd_org_user" {
descriere = "Utilizator vCD Tenant"
}
variabilă "vcd_org_password" {
descriere = "Parola vCD Tenant"
}
variabilă "vcd_org" {
descriere = "Organizația vCD Tenant"
}
variabilă "vcd_org_vdc" {
descriere = "VDC vCD Tenant"
}
variabilă "vcd_org_url" {
descriere = "URL vCD Tenant"
}
variabilă "vcd_org_max_retry_timeout" {
implicit = "60"
}
variabilă "vcd_org_allow_unverified_ssl" {
implicit = "adevărat"
}
variabilă "vcd_org_edge_name" {
descriere = "numele edge-ului vCD"
}
variabilă "vcd_org_catalog" {
descriere = "catalog public vCD"
}
variabilă "vcd_template_os_centos7" {
descriere = "OS CentOS 7"
implicit = "CentOS7"
}
variabilă "vcd_org_ssd_sp" {
descriere = "Politici de stocare"
implicit = "Politica de stocare de aur"
}
variabilă "vcd_org_hdd_sp" {
descriere = "Politici de stocare"
implicit = "Politica de stocare de bronz"
}
variabilă "vcd_edge_local_subnet" {
descriere = "Subrețeaua Organizației"
}
variabilă "vcd_edge_external_ip" {
descriere = "IP public extern"
}
variabilă "vcd_edge_local_ip_nginx" {}
variabilă "vcd_edge_local_ip_bitrix" {}
variabilă "vcd_edge_local_ip_nextcloud" {}
variabilă "vcd_edge_external_network" {}
Valorile variabilelor pe care le primim de la furnizor.
vcd_org_user — numele utilizatorului cu drepturi de Administrator al Organizației,
vcd_org_password — parola utilizatorului,
vcd_org — numele organizației,
vcd_org_vdc — numele centrului de date virtual,
vcd_org_url — URL API,
vcd_org_edge_name — numele router-ului virtual,
vcd_org_catalog — numele catalogului cu șabloane de mașini virtuale,
vcd_edge_external_ip — adresa IP publică,
vcd_edge_external_network — numele rețelei externe,
vcd_org_hdd_sp — numele politicii de stocare HDD,
vcd_org_ssd_sp — numele politicii de stocare SSD.
Și introducem propriile variabile:
vcd_edge_local_ip_nginx — adresa IP a mașinii virtuale cu NGINX,
vcd_edge_local_ip_bitrix — adresa IP a mașinii virtuale cu 1C: Bitrix,
vcd_edge_local_ip_nextcloud — adresa IP a mașinii virtuale cu Nextcloud.
În al doilea fișier creăm și specificăm variabile pentru modulul VMware vCloud Director în fișierul vcd.tfvars: Să ne amintim că în exemplul nostru folosim , dacă lucrați cu un alt furnizor, verificați valorile cu acesta.
Conținutul fișierului vcd.tfvars.
vcd_org_url = "https://vcloud.mclouds.ro/api"
vcd_org_user = "orgadmin"
vcd_org_password = "*"
vcd = "org"
vcd_org_vdc = "orgvdc"
vcd_org_maxretry_timeout = 60
vcd_org_allow_unverified_ssl = adevărat
vcd_org_catalog = "Templates"
vcd_templateos_centos7 = "CentOS7"
vcd_org_ssd_sp = "Politica de stocare de aur"
vcd_org_hdd_sp = "Politica de stocare de bronz"
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"
Configurația rețelei, network.tf.
Variabilele de mediu sunt setate, acum să configurăm schema de conectare a mașinilor virtuale — vom aloca o adresă IP privată pentru fiecare mașină virtuală și vom utiliza Destination NAT pentru a redirecționa porturile către rețeaua externă. Pentru a restricționa accesul la porturile de control, vom permite accesul doar pentru adresa noastră IP.
Schema de rețea pentru platforma Terraform creată
Creăm o rețea organizațională virtuală numită net_lan01, cu un gateway implicit: 192.168.110.254, precum și cu un spațiu de adresare: 192.168.110.0/24.
Definim rețeaua 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"
}
}
Vom crea reguli pentru firewall care permit accesul mașinilor virtuale la rețeaua Internet. În cadrul acestui bloc, toate resursele virtuale din cloud vor avea acces la Internet:
Definim regulile pentru accesul VM la 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]
}
Stabilind o dependență, după ce blocul vcdnetworkrouted.net este procesat, vom trece la configurarea blocului vcdnsxvfirewallrule, prin dependson. Folosim această opțiune, deoarece unele dependențe pot fi recunoscute implicit în configurație.
Apoi vom crea reguli care permit accesul la porturi din rețeaua externă și specificăm adresa noastră IP pentru conectarea prin SSH la servere. Orice utilizator din rețeaua Internet are acces la porturile 80 și 443 pe serverul web, iar utilizatorul cu adresa IP 90.1.15.1 are acces la porturile SSH ale serverelor virtuale.
Permitem accesul la porturi din rețeaua externă.
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]
}
Creăm reguli Source NAT pentru accesul la rețeaua Internet din rețeaua locală cloud:
Definim regulile 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]
}
Și la finalul configurației blocului de rețele, adăugăm reguli Destination NAT pentru accesul la serviciile din rețeaua externă:
Adăugăm reguli 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"
adresa_originală = var.vcd_edge_external_ip
port_original = 443
adresa_tradusă = var.vcd_edge_local_ip_nginx
port_tradus = 443
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
resursa "vcd_nsxv_dnat" "dnat_tcp_nginx_http" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descriere = "NGINX HTTP"
adresa_originală = var.vcd_edge_external_ip
port_original = 80
adresa_tradusă = var.vcd_edge_local_ip_nginx
port_tradus = 80
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adăugăm o regulă NAT pentru traducerea porturilor către serverul SSH sub Nginx.
resursa "vcd_nsxv_dnat" "dnat_tcp-nginx_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descriere = "SSH NGINX"
adresa_originală = var.vcd_edge_external_ip
port_original = 58301
adresa_tradusă = var.vcd_edge_local_ip_nginx
port_tradus = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adăugăm o regulă NAT pentru traducerea porturilor către serverul SSH cu 1C-Bitrix.
resursa "vcd_nsxv_dnat" "dnat_tcp_bitrix_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descriere = "SSH Bitrix"
adresa_originală = var.vcd_edge_external_ip
port_original = 58302
adresa_tradusă = var.vcd_edge_local_ip_bitrix
port_tradus = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Adăugăm o regulă NAT pentru traducerea porturilor către serverul SSH cu Nextcloud.
resursa "vcd_nsxv_dnat" "dnat_tcp_nextcloud_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
network_type = "ext"
descriere = "SSH Nextcloud"
adresa_originală = var.vcd_edge_external_ip
port_original = 58303 adresa_tradusă = var.vcd_edge_local_ip_nextcloud
port_tradus = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Configurarea mediului virtual main.tf
Așa cum am planificat la începutul articolului, vom crea trei mașini virtuale. Acestea vor fi pregătite folosind „Guest Customization”. Parametrii rețelei vor fi specificați conform setărilor menționate de noi, iar parola pentru utilizator va fi generată automat.
Vom descrie vApp-ul în care se vor afla mașinile virtuale și configurația acestora.
Configurarea mașinilor virtuale
Vom crea un container vApp. Astfel, putem conecta imediat vApp-ul și VM-urile la rețeaua virtuală, adăugând de asemenea parametrul depends_on:
Creăm containerul
resursa "vcd_vapp" "vapp" {
nume = "web"
pornire = "true" depends_on = [vcd_network_routed.net]
}
Vom crea o mașină virtuală cu descrierea
resursa "vcd_vapp_vm" "nginx" {
nume_vapp = vcd_vapp.vapp.name
nume = "nginx"
nume_catalog = var.vcd_org_catalog
nume_template = var.vcd_template_os_centos7
profil_stocare = var.vcd_org_ssd_sp
memorie = 8192
cpus = 1
miezuri_cpu = 1
rețea {
tip = "org"
nume = vcd_network_routed.net.name
este_principal = true
tip_adaptor = "VMXNET3"
mod_alocare_ip = "MANUAL"
ip = var.vcd_edge_local_ip_nginx
}
suprascriere_template_disk {
tip_bus = "paravirtual"
dimensiune_in_mb = "32768"
număr_bus = 0
număr_unitate = 0
profil_stocare = var.vcd_org_ssd_sp
}
}
Parametrii principali în descrierea VM:
nume — numele mașinii virtuale,
nume_vapp — denumirea vApp în care se va adăuga noul VM,
nume_catalog / nume_template — numele catalogului și numele șablonului pentru mașina virtuală,
profil_stocare — politica de stocare implicită.
Parametrii blocului rețea:
tip — tipul rețelei conectate,
nume — la ce rețea virtuală se va conecta VM,
este_principal — adaptorul de rețea principal,
mod_alocare_ip — modul de alocare a adresei MANUAL / DHCP / POOL,
ip — adresa IP pentru mașina virtuală, pe care o vom specifica manual.
Blocul suprascriere_template_disk:
dimensiuneinmb — dimensiunea boot-diskului pentru mașina virtuală
profil_stocare — politica de stocare pentru disk
Vom crea a doua VM cu descrierea stocării fișierelor Nextcloud
resursa "vcd_vapp_vm" "nextcloud" {
nume_vapp = vcd_vapp.vapp.name
nume = "nextcloud"
nume_catalog = var.vcd_org_catalog
nume_template = var.vcd_template_os_centos7
profil_stocare = var.vcd_org_ssd_sp
memorie = 8192
cpus = 1
miezuri_cpu = 1
rețea {
tip = "org"
nume = vcd_network_routed.net.name
este_principal = true
tip_adaptor = "VMXNET3"
mod_alocare_ip = "MANUAL"
ip = var.vcd_edge_local_ip_nextcloud
}
suprascriere_template_disk {
tip_bus = "paravirtual"
dimensiune_in_mb = "32768"
număr_bus = 0
număr_unitate = 0
profil_stocare = 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 ]
}
În secțiunea vcdvminternal_disk vom descrie un nou disc virtual, care se conectează la mașina virtuală.
Explicații pentru blocul vcdvminternaldisk:
bustype — tipul controlerului de disc
sizeinmb — dimensiunea discului
busnumber / unitnumber — locul de conectare în adaptor
profil_stocare — politica de stocare pentru disk
Vom descrie ultima VM pe Bitrix
resource "vcd_vapp_vm" "bitrix" {
nume_vapp = vcd_vapp.vapp.name
name = "bitrix"
nume_catalog = var.vcd_org_catalog
nume_template = var.vcd_template_os_centos7
profil_stocare = var.vcd_org_ssd_sp
memorie = 8192
cpus = 1
miezuri_cpu = 1
rețea {
tip = "org"
nume = vcd_network_routed.net.name
este_principal = true
tip_adaptor = "VMXNET3"
mod_alocare_ip = "MANUAL"
ip = var.vcd_edge_local_ip_bitrix
}
suprascriere_template_disk {
tip_bus = "paravirtual"
size_in_mb = "81920"
număr_bus = 0
număr_unitate = 0
profil_stocare = var.vcd_org_ssd_sp
}
}
Actualizarea sistemului de operare și instalarea scripturilor suplimentare
Rețeaua este pregătită, mașinile virtuale sunt descrise. Înainte de a importa infrastructura noastră, putem efectua o provizionare inițială folosind blocurile de provisioneri și fără a folosi Ansible.
Să vedem cum se actualizează sistemul de operare și se lansează scriptul de instalare CMS Bitrix cu ajutorul blocului provisioner.
Mai întâi, vom instala pachetele de actualizare pentru 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" ]
}
}
}
Definiția componentelor:
provisioner «remote-exec» — ne conectăm cu blocul de provizionare la distanță
În blocul connection descriem tipul și parametrii pentru conectare:
type — protocolul, în cazul nostru SSH;
user — numele utilizatorului;
password — parola utilizatorului. În cazul nostru, ne referim la parametrul vcdvappvm.nginx.customization[0].admin_password, care stochează parola generată pentru utilizatorul sistemului.
host — adresa IP externă pentru conectare;
port — portul pentru conectare, care a fost specificat anterior în setările DNAT;
inline — enumerăm lista de comenzi care vor fi introduse. Comenzile vor fi introduse în ordinea specificată în această secțiune.
Ca exemplu, vom efectua suplimentar scriptul de instalare 1C-Bitrix. Ieșirea rezultatului execuției scriptului va fi disponibilă în timpul execuției planului. Pentru a instala scriptul, mai întâi vom descrie blocul:
Vom descrie instalarea 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"
]
}
Și imediat vom descrie actualizarea Bitrix.
Exemplu de provizionare 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"
]
}
}
Important! The script may not work if SELinux is not disabled in advance! If you need a detailed article on installing and configuring CMS 1C-Bitrix using bitrix-env.sh, you can .
3. Infrastructure Initialization
Initialization of modules and plugins
For this task, we use a simple 'gentleman's set': a laptop with Windows 10 and a distribution from the official site . We will unpack and initialize it with the following command: terraform.exe init
After describing the computational and network infrastructure, we run the planning to check our configuration, where we can see what will be created and how they are interconnected.
We execute the command
- terraform plan -var-file=vcd.tfvars.We receive the result
- Plan: 16 to add, 0 to change, 0 to destroy.So, according to this plan, 16 resources will be created.We start the plan with the command
- terraform.exe apply -var-file=vcd.tfvars.
The virtual machines will be created, and then the packages we listed in the provisioner section will be executed — the OS will be updated and CMS Bitrix will be installed.
Fetching connection data
After executing the plan, we want to obtain the connection data for the servers in text format; for this, we will format the output section as follows:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
And the next output provides us with the password for the created virtual machine:
Outputs: nginx_password = F#4u8!!N
As a result, we gain access to virtual machines with the updated operating system and pre-installed packages for our further work. Everything is ready!
But what if you already have an existing infrastructure?
3.1. Working with Terraform in an Existing Infrastructure
It's simple, you can import the current virtual machines and their vApp containers using the import command.
Let's describe the vAPP resource and the virtual machine.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
The next step is to import the properties of the vApp resources in the format vcdvapp. .., unde:
vApp — name of the vApp;
org — name of the organization;
org_vdc — name of the virtual data center.
Importing vAPP resource properties
We will import the properties of the VM resources in the format: vcdvappvm. ..., în care:
VM — name of the VM;
vApp — name of the vApp;
org — name of the organization;
orgvdc — name of the virtual data center.
The import was successful.
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importare din ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import pregătit!
vcd_vapp_vm pregătit pentru import
vcd_vapp_vm.Zabbix: Actualizare stare... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Importare reușită!
Resursele importate sunt afișate mai sus. Aceste resurse sunt acum în
starea dumneavoastră Terraform și vor fi gestionate de Terraform de acum înainte.
Acum putem examina noua resursă importată:
Resursă importată
> terraform show
...
# vcd_vapp.Monitoring:
resource "vcd_vapp" "Monitoring" {
guest_properties = {}
href = "https://vcloud.mclouds.ro/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.ro/api/vApp/vm-778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
id = "urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
internal_disk = [
{
număr_bus = 0
tip_bus = "paravirtual"
disk_id = "2000"
iops = 0
size_in_mb = 122880
storage_profile = "Gold Storage Policy"
thin_provisioned = true
număr_unitate = 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
}
rețea {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Acum este sigur gata — am finalizat cu ultimul detaliu (importul în infrastructura existentă) și am discutat toate aspectele principale legate de utilizarea Terraform.
Instrumentul s-a dovedit a fi foarte util și permite descrierea infrastructurii dvs. ca un cod, începând de la mașinile virtuale ale unui furnizor de cloud până la descrierea resurselor componentelor de rețea.
În plus, independența de mediu permite lucrul atât cu resursele locale, cât și cu cele de cloud și, când nu există o platformă suportată, se poate scrie un propriul furnizor și folosi.
Sursa: habr.com
