I den här artikeln ska vi titta på vad Terraform består av, och även successivt lansera vår egen infrastruktur — vi kommer att förbereda tre virtuella datorer för olika ändamål: proxy, fillagring och CMS.
Om allt i detalj och i tre steg:
1. Terraform - beskrivning, fördelar och komponenter
Terraform är ett IaC-verktyg (Infrastructure-as-Code) för att bygga och hantera virtuell infrastruktur med hjälp av kod.
Vi noterade flera fördelar med att arbeta med verktyget:
-
Utbyggnadshastighet för nya hyresgäster (anpassade virtuella miljöer). Vanligtvis gäller att ju fler nya kunder det finns, desto fler "klick" behöver teknisk supportpersonal göra för att publicera nya resurser. Med Terraform kan användare ändra inställningar för virtuella datorer (till exempel automatiskt stänga av operativsystemet och öka den virtuella diskpartitionen) utan att behöva teknisk support eller stänga av själva maskinen.
-
Omedelbar verifiering av aktiveringsplanen nya Tennant. Med hjälp av beskrivningen av infrastrukturkoden kan vi omedelbart kontrollera vad som kommer att läggas till och i vilken ordning, samt i vilket sluttillstånd den eller den virtuella maskinen eller virtuella nätverk med anslutningar till virtuella maskiner kommer att vara.
-
Möjlighet att beskriva de mest populära molnplattformarna. Du kan använda verktyget från Amazon och Google Cloud, till privata plattformar baserade på VMware vCloud Director, som erbjuder tjänster inom IaaS, SaaS och PaaS-lösningar.
-
Hantera flera molnleverantörer och distribuera infrastrukturen mellan dem för att förbättra feltoleransen, genom att använda en enda konfiguration för att skapa, diagnostisera och hantera molnresurser.
-
Bekväm användning för att skapa demoställ för mjukvarutestning och felsökning. Du kan skapa och överföra stativ för testavdelningen, testa mjukvara i olika miljöer parallellt och omedelbart ändra och ta bort resurser genom att bara skapa en resursbyggplan
"Terrarium" Terraform
Vi pratade kort om fördelarna med verktyget, låt oss nu dela upp det i dess komponenter
Leverantörer.
I Terraform kan nästan vilken typ av infrastruktur som helst representeras som en resurs. Kopplingen mellan resurser och API-plattformen tillhandahålls av leverantörsmoduler, som låter dig skapa resurser inom en specifik plattform, till exempel Azure eller VMware vCloud Director.
Som en del av projektet kan du interagera med olika leverantörer på olika plattformar.
Resurser (resursbeskrivning).
Beskrivning av resurser låter dig hantera plattformskomponenter, såsom virtuella maskiner eller nätverk.
Du kan själv skapa en resursbeskrivning för VMware vCloud Director-leverantören och använda den här beskrivningen för att skapa resurser hos vilken värdleverantör som helst som använder vCloud Director. Du behöver bara ändra autentiseringsparametrarna och nätverksanslutningsparametrarna till den värdleverantör som krävs
Proviantörer.
Denna komponent gör det möjligt att utföra operationer för den initiala installationen och underhållet av operativsystemet efter att ha skapat virtuella maskiner. När du har skapat en virtuell maskinresurs kan du använda provisioner för att konfigurera och ansluta via SSH, uppdatera operativsystemet och ladda ner och köra ett skript.
In- och utdatavariabler.
Indatavariabler - indatavariabler för alla blocktyper.
Utdatavariabler låter dig spara värden efter att du har skapat resurser och kan användas som indatavariabler i andra moduler, till exempel i Provisioners-blocket.
stater.
Tillståndsfiler lagrar information om konfigurationen av leverantörsplattformsresurser. När plattformen först skapas finns det ingen information om resurser och innan någon operation uppdaterar Terraform tillståndet med den verkliga infrastrukturen för de resurser som redan beskrivits.
Huvudsyftet med stater är att spara ett gäng objekt med redan skapade resurser för att jämföra konfigurationen av tillagda resurser och objekt för att undvika upprepade skapande och ändringar av plattformen.
Som standard lagras tillståndsinformation i den lokala filen terraform.tfstate, men vid behov är det möjligt att använda fjärrlagring för lagarbete.
Du kan också importera nuvarande plattformsresurser till status för att ytterligare interagera med andra resurser som i sin tur skapades utan hjälp av Terraform.
2. Skapande av infrastruktur
Komponenterna har sorterats ut, nu kommer vi med Terraform successivt att skapa en infrastruktur med tre virtuella maskiner. Den första med nginx-proxyservern installerad, den andra med fillagring baserad på Nextcloud och den tredje med CMS Bitrix.
Vi kommer att skriva kod och köra den med vårt exempel . Våra användare får ett konto med organisationsadministratörsrättigheter. Om du använder ett konto med samma rättigheter i ett annat VMware-moln kan du återskapa koden från våra exempel. Gå!
Låt oss först skapa en katalog för vårt nya projekt där filer som beskriver infrastrukturen kommer att placeras.
mkdir project01
Därefter beskriver vi infrastrukturkomponenterna. Terraform skapar relationer och bearbetar filer utifrån beskrivningen i filerna. Filerna i sig kan namnges utifrån syftet med blocken som beskrivs, till exempel network.tf - beskriver nätverksparametrarna för infrastrukturen.
För att beskriva komponenterna i vår infrastruktur skapade vi följande filer:
Lista över filer.
main.tf - beskrivning av parametrar för den virtuella miljön - virtuella maskiner, virtuella behållare;
network.tf - beskrivning av virtuella nätverksparametrar och NAT- och brandväggsregler;
variables.tf - lista över variabler som vi använder;
vcd.tfvars - projektvariabelvärden för VMware vCloud Director-modulen.
Konfigurationsspråket i Terraform är deklarativt och ordningen på blocken spelar ingen roll, förutom provisionerblocken, eftersom i detta block beskriver vi de kommandon som ska köras när infrastrukturen förbereds och de kommer att köras i ordning.
Blockstruktur.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
För att beskriva block används det egna programmeringsspråket HCL (HashiCorp Configuration Language), det är möjligt att beskriva infrastrukturen med JSON. Du kan lära dig mer om syntaxen .
Konfiguration av miljövariabler, variables.tf och vcd.tfvars
Låt oss först skapa två filer som beskriver listan över alla använda variabler och deras värden för VMware vCloud Director-modulen. Låt oss först skapa filen variables.tf.
Innehållet i filen variables.tf.
variable "vcd_org_user" {
description = "vCD Tenant User"
}
variable "vcd_org_password" {
description = "vCD Tenant Password"
}
variable "vcd_org" {
description = "vCD Tenant Org"
}
variable "vcd_org_vdc" {
description = "vCD Tenant VDC"
}
variable "vcd_org_url" {
description = "vCD Tenant URL"
}
variable "vcd_org_max_retry_timeout" {
default = "60"
}
variable "vcd_org_allow_unverified_ssl" {
default = "true"
}
variable "vcd_org_edge_name" {
description = "vCD edge name"
}
variable "vcd_org_catalog" {
description = "vCD public catalog"
}
variable "vcd_template_os_centos7" {
description = "OS CentOS 7"
default = "CentOS7"
}
variable "vcd_org_ssd_sp" {
description = "Storage Policies"
default = "Gold Storage Policy"
}
variable "vcd_org_hdd_sp" {
description = "Storage Policies"
default = "Bronze Storage Policy"
}
variable "vcd_edge_local_subnet" {
description = "Organization Network Subnet"
}
variable "vcd_edge_external_ip" {
description = "External public IP"
}
variable "vcd_edge_local_ip_nginx" {}
variable "vcd_edge_local_ip_bitrix" {}
variable "vcd_edge_local_ip_nextcloud" {}
variable "vcd_edge_external_network" {}
Variable värden som vi får från leverantören.
-
vcd_org_user — användarnamn med organisationsadministratörsrättigheter,
-
vcd_org_password — användarlösenord,
-
vcd_org — namnet på organisationen,
-
vcd_org_vdc — namnet på det virtuella datacentret,
-
vcd_org_url - API URL,
-
vcd_org_edge_name — namnet på den virtuella routern,
-
vcd_org_catalog — namnet på katalogen med virtuella maskinmallar,
-
vcd_edge_external_ip — offentlig IP-adress,
-
vcd_edge_external_network — namnet på det externa nätverket,
-
vcd_org_hdd_sp — namnet på hårddiskens lagringspolicy,
-
vcd_org_ssd_sp — namnet på SSD-lagringspolicyn.
Och ange våra variabler:
-
vcd_edge_local_ip_nginx — IP-adressen för den virtuella maskinen med NGINX,
-
vcd_edge_local_ip_bitrix - IP-adress för den virtuella maskinen med 1C: Bitrix,
-
vcd_edge_local_ip_nextcloud — IP-adressen för den virtuella maskinen med Nextcloud.
Med den andra filen skapar och specificerar vi variabler för VMware vCloud Director-modulen i filen vcd.tfvars: Låt oss komma ihåg att vi i vårt exempel använder , om du arbetar med en annan leverantör, kontrollera värdena med dem.
Innehållet i filen vcd.tfvars.
vcd_org_url = "https://vcloud.mclouds.ru/api"
vcd_org_user = "orgadmin"
vcd_org_password = "*"
vcd = "org"
vcd_org_vdc = "orgvdc"
vcd_org_maxretry_timeout = 60
vcd_org_allow_unverified_ssl = true
vcd_org_catalog = "Templates"
vcd_templateos_centos7 = "CentOS7"
vcd_org_ssd_sp = "Gold Storage Policy"
vcd_org_hdd_sp = "Bronze Storage Policy"
vcd_org_edge_name = "MCLOUDS-EDGE"
vcd_edge_external_ip = "185.17.66.1"
vcd_edge_local_subnet = "192.168.110.0/24"
vcd_edge_local_ip_nginx = "192.168.110.1"
vcd_edge_local_ip_bitrix = "192.168.110.10"
vcd_edge_local_ip_nextcloud = "192.168.110.11"
vcd_edge_external_network = "NET-185-17-66-0"
Nätverkskonfiguration, nätverk.tf.
Miljövariablerna är inställda, nu ställer vi in anslutningsschemat för den virtuella maskinen - vi tilldelar en privat IP-adress till varje virtuell maskin och använder Destination NAT för att "vidarebefordra" portarna till det externa nätverket. För att begränsa åtkomsten till hanteringsportar ställer vi endast in åtkomst för vår IP-adress.
Nätverksdiagram för Terraform-plattformen som skapas
Vi skapar ett virtuellt organisatoriskt nätverk med namnet net_lan01, standardgatewayen: 192.168.110.254, och även med adressutrymmet: 192.168.110.0/24.
Vi beskriver ett virtuellt nätverk.
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"
}
}
Låt oss skapa brandväggsregler som tillåter virtuella maskiner att komma åt Internet. Inom detta block kommer alla virtuella resurser i molnet att ha tillgång till Internet:
Vi beskriver reglerna för VM-åtkomst till 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]
}
Efter att ha fastställt beroendet att efter bearbetning av vcdnetworkrouted.net-blocket fortsätter vi att konfigurera vcdnsxvfirewall-regelblocket, genom att använda beror på. Vi använder det här alternativet eftersom vissa beroenden kan kännas igen implicit i konfigurationen.
Därefter kommer vi att skapa regler som tillåter åtkomst till portar från det externa nätverket och anger vår IP-adress för anslutning via SSH till servrarna. Alla Internetanvändare har tillgång till portarna 80 och 443 på webbservern, och en användare med IP-adressen 90.1.15.1 har tillgång till SSH-portarna på de virtuella servrarna.
Tillåt åtkomst till portar från det externa nätverket.
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]
}
Vi skapar käll-NAT-regler för åtkomst till Internet från ett lokalt molnnätverk:
Vi beskriver Source NAT-reglerna.
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]
}
Och för att slutföra konfigurationen av nätverksblocket lägger vi till Destination NAT-regler för åtkomst till tjänster från det externa nätverket:
Lägger till Destination NAT-regler.
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]
}
Lägg till en NAT-regel för portöversättning till SSH-servern under 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]
}
Lägg till en NAT-regel för portöversättning till SSH-servern med 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]
}
Lägg till en NAT-regel för portöversättning till SSH-servern med 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]
}
Main.tf virtuell miljökonfiguration
Som vi planerade i början av artikeln kommer vi att skapa tre virtuella maskiner. De kommer att förberedas med hjälp av "Gästanpassning". Vi kommer att ställa in nätverksparametrarna enligt de inställningar vi angav, och användarlösenordet genereras automatiskt.
Låt oss beskriva vApp där de virtuella maskinerna kommer att finnas och deras konfiguration.
Konfiguration av virtuell maskin
Låt oss skapa en vApp-behållare. Så att vi omedelbart kan ansluta vApp och VM till det virtuella nätverket, lägger vi också till parameterndependent_on:
Skapa en behållare
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Låt oss skapa en virtuell maskin med en beskrivning
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
}
}
Huvudparametrar i VM-beskrivningen:
-
namn — namnet på den virtuella maskinen,
-
vappname - namnet på vApp som en ny virtuell dator ska läggas till,
-
katalognamn / mallnamn - katalognamn och virtuell maskinmallnamn,
-
storageprofile - standardlagringspolicy.
Nätverksblockparametrar:
-
typ — typ av anslutet nätverk,
-
namn — vilket virtuellt nätverk att ansluta den virtuella datorn till,
-
isprimary - primär nätverksadapter,
-
ipallocation_mode — MANUELL / DHCP / POOL adressallokeringsläge,
-
ip — IP-adress för den virtuella maskinen, vi kommer att ange den manuellt.
override_template_disk block:
-
sizeinmb — storlek på startdisken för den virtuella maskinen
-
storage_profile — lagringspolicy för disken
Låt oss skapa en andra virtuell dator med en beskrivning av Nextcloud-fillagringen
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 ]
}
I avsnittet vcdvminternal_disk kommer vi att beskriva en ny virtuell disk som är ansluten till den virtuella maskinen.
Förklaringar till vcdvminternaldisk-blocket:
-
bustype - diskstyrenhetstyp
-
sizeinmb — diskstorlek
-
bussnummer / enhetsnummer - anslutningsplats i adaptern
-
storage_profile — lagringspolicy för disken
Låt oss beskriva den senaste virtuella datorn på 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
}
}
Uppdatera operativsystemet och installera ytterligare skript
Nätverket förbereds, de virtuella maskinerna beskrivs. Innan vi importerar vår infrastruktur kan vi utföra initial provisionering i förväg med hjälp av provisionerblock och utan att använda Ansible.
Låt oss titta på hur du uppdaterar operativsystemet och kör CMS Bitrix-installationsskriptet med hjälp av provisioneringsblocket.
Låt oss först installera CentOS-uppdateringspaket.
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" ]
}
}
}
Beteckning på komponenter:
-
provisioner "remote-exec" - anslut fjärrprovisioneringsblocket
-
I anslutningsblocket beskriver vi typen och parametrarna för anslutningen:
-
typ — protokoll, i vårt fall SSH;
-
användare — användarnamn;
-
lösenord — användarlösenord. I vårt fall pekar vi på parametern vcdvappvm.nginx.customization[0].admin_password, som lagrar det genererade lösenordet för systemanvändaren.
-
värd — extern IP-adress för anslutning;
-
port — port för anslutning, som tidigare specificerades i DNAT-inställningarna;
-
inline - lista listan över kommandon som kommer att anges. Kommandona kommer att matas in i den ordning som anges i detta avsnitt.
Som ett exempel, låt oss dessutom köra installationsskriptet 1C-Bitrix. Utdata från skriptkörningsresultatet kommer att vara tillgänglig medan planen körs. För att installera skriptet beskriver vi först blocket:
Låt oss beskriva installationen av 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"
]
}
Och vi kommer omedelbart att beskriva Bitrix-uppdateringen.
Ett exempel på 1C-Bitrix-provisionering.
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"
]
}
}
Viktig! Skriptet kanske inte fungerar om du inte inaktiverar SELinux i förväg! Om du behöver en detaljerad artikel om att installera och konfigurera CMS 1C-Bitrix med bitrix-env.sh, oo kan du .
3. Initiering av infrastruktur
Initiera moduler och plugins
För arbete använder vi ett enkelt "gentleman's kit": en bärbar dator med Windows 10 OS och ett distributionspaket från den officiella webbplatsen . Låt oss packa upp och initiera med kommandot: terraform.exe init
Efter att ha beskrivit dator- och nätverksinfrastrukturen startar vi planering för att testa vår konfiguration, där vi kan se vad som kommer att skapas och hur det kommer att kopplas till varandra.
-
Utför kommandot
- terraform plan -var-file=vcd.tfvars. -
Vi får resultatet
- Plan: 16 to add, 0 to change, 0 to destroy.Det vill säga enligt denna plan ska 16 resurser skapas. -
Vi lanserar planen på kommando
- terraform.exe apply -var-file=vcd.tfvars.
Virtuella maskiner kommer att skapas, och sedan kommer paketen vi har listat att exekveras inom provisioneringssektionen - OS kommer att uppdateras och CMS Bitrix kommer att installeras.
Tar emot anslutningsinformation
Efter att ha utfört planen vill vi ta emot data i textform för att ansluta till servrarna, för detta kommer vi att formatera utdatasektionen enligt följande:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
Och följande utdata berättar om lösenordet för den skapade virtuella maskinen:
Outputs: nginx_password = F#4u8!!N
Som ett resultat får vi tillgång till virtuella maskiner med ett uppdaterat operativsystem och förinstallerade paket för vårt fortsatta arbete. Allt är klart!
Men vad händer om du redan har befintlig infrastruktur?
3.1. Fungerar Terraform med befintlig infrastruktur
Det är enkelt, du kan importera aktuella virtuella maskiner och deras vApp-behållare med hjälp av importkommandot.
Låt oss beskriva vAPP-resursen och den virtuella maskinen.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
Nästa steg är att importera egenskaperna för vApp-resurser i formatet vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, Var:
-
vApp - vApp-namn;
-
org — organisationens namn;
-
org_vdc — namnet på det virtuella datacentret.
Importera vAPP-resursegenskaper
Låt oss importera egenskaperna för VM-resurser i formatet: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, i vilken:
-
VM - VM-namn;
-
vApp - vApp-namn;
-
org — organisationens namn;
-
orgvdc är namnet på det virtuella datacentret.
Importen lyckades
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importing from ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import prepared!
Prepared vcd_vapp_vm for import
vcd_vapp_vm.Zabbix: Refreshing state... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import successful!
The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.
Nu kan vi titta på den nya importerade resursen:
Importerad resurs
> terraform show
...
# vcd_vapp.Monitoring:
resource "vcd_vapp" "Monitoring" {
guest_properties = {}
href = "https://vcloud.mclouds.ru/api/vApp/vapp-fe5db285-a4af-47c4-93e8-55df92f006ec"
id = "urn:vcloud:vapp:fe5db285-a4af-47c4-93e8-55df92f006ec"
ip = "allocated"
metadata = {}
name = "Monitoring"
org = "mClouds"
status = 4
status_text = "POWERED_ON"
vdc = "mClouds"
}
…
# vcd_vapp_vm.Zabbix:
resource "vcd_vapp_vm" "Zabbix" {
computer_name = "Zabbix"
cpu_cores = 1
cpus = 2
expose_hardware_virtualization = false
guest_properties = {}
hardware_version = "vmx-14"
href = "https://vcloud.mclouds.ru/api/vApp/vm-778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
id = "urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
internal_disk = [
{
bus_number = 0
bus_type = "paravirtual"
disk_id = "2000"
iops = 0
size_in_mb = 122880
storage_profile = "Gold Storage Policy"
thin_provisioned = true
unit_number = 0
},
]
memory = 8192
metadata = {}
name = "Zabbix"
org = "mClouds"
os_type = "centos8_64Guest"
storage_profile = "Gold Storage Policy"
vapp_name = "Monitoring"
vdc = "mClouds"
customization {
allow_local_admin_password = true
auto_generate_password = true
change_sid = false
enabled = false
force = false
join_domain = false
join_org_domain = false
must_change_password_on_first_login = false
number_of_auto_logons = 0
}
network {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Nu är vi definitivt klara - vi är klara med den sista punkten (import till befintlig infrastruktur) och har övervägt alla huvudpunkter med att arbeta med Terraform.
Verktyget visade sig vara mycket bekvämt och låter dig beskriva din infrastruktur som kod, från virtuella maskiner från en molnleverantör till att beskriva resurserna för nätverkskomponenter.
Samtidigt gör oberoendet från omgivningen det möjligt att arbeta med lokala molnresurser och till och med hantera plattformen. Och om det inte finns någon plattform som stöds och du vill lägga till en ny kan du skriva din egen leverantör och använda den.
Källa: will.com