In dit artikel bespreken we waaruit Terraform bestaat en zetten we stap voor stap onze eigen infrastructuur op — we bereiden drie VM's voor verschillende doeleinden voor: proxy, bestandsopslag en CMS.
Alles in detail en in drie stappen:
1. Terraform — beschrijving, voordelen en componenten
Terraform is een IaC (Infrastructure-as-Code) tool voor het opbouwen en beheren van virtuele infrastructuur met behulp van code.
Tijdens het werken met de tool hebben we verschillende voordelen opgemerkt:
Snelheid van de uitrol van nieuwe tenants (gebruikersvirtuele omgevingen). Gewoonlijk, hoe meer nieuwe klanten, hoe meer 'kliks' er nodig zijn voor technische ondersteuning om nieuwe middelen beschikbaar te stellen. Met Terraform kunnen gebruikers parameters van virtuele machines aanpassen (bijvoorbeeld het automatisch uitschakelen van het besturingssysteem en het vergroten van de partitie van de virtuele schijf) zonder dat technische ondersteuning of het uitschakelen van de machine nodig is.
Onmiddellijke controle van het activatieplan van de nieuwe tenant. Met de beschrijving van de infrastructuurcode kunnen we onmiddellijk controleren wat en in welke volgorde zal worden toegevoegd, evenals in welke eindtoestand een bepaalde virtuele machine of virtueel netwerk met verbindingen naar virtuele machines zal verkeren.
Mogelijkheid om de meeste populaire cloudplatformen te beschrijven. Je kunt de tool gebruiken van Amazon en Google Cloud tot privéplatforms op basis van VMware vCloud Director, die diensten bieden binnen IaaS, SaaS en PaaS-oplossingen.
Beheer van meerdere cloudproviders en verspeiding van infrastructuur tussen hen voor verhoogde fouttolerantie, terwijl je één configuratie gebruikt voor het creëren, diagnosticeren en beheren van cloudresources.
Gebruiksvriendelijkheid voor het creëren van demo-omgevingen voor softwaretesting en debugging. Je kunt omgevingen creëren en doorgeven aan de testafdeling, software gelijktijdig in verschillende omgevingen controleren en onmiddellijk middelen wijzigen en verwijderen met slechts één resourcebouwplan.
‘Terrarium’ Terraform
We have briefly discussed the advantages of the tool, now let's break it down into its components.
Providers.
In Terraform, almost any type of infrastructure can be represented as a resource. The connection between resources and the API platform is ensured by provider modules, which allow creating resources within a specific platform, such as Azure or VMware vCloud Director.
In the project, you can interact with different providers on different platforms.
Resources.
Resource descriptions allow you to manage platform components, such as virtual machines or networks.
You can create a resource description for the VMware vCloud Director provider and use this description to create resources with any hosting provider that uses vCloud Director. You will only need to change the authentication parameters and network connection parameters for the necessary hosting provider.
Provisioners.
This component allows performing initial installation and maintenance operations on the operating system after virtual machines are created. After creating a virtual machine resource, using provisioners you can configure and connect via SSH, update the operating system, and upload and execute a script.
Input and Output Variables.
Input variables are the input variables for any type of blocks.
Output variables allow saving values after resources are created and can be used as input variables in other modules, for instance, in the Provisioners block.
States..
State files store information about the configuration of provider platform resources. Upon first creation of the platform, there is no information about resources, and before any operation, Terraform updates the state with the real infrastructure of the already described resources.
The main purpose of states is to save the binding of objects of already created resources to compare the configuration of added resources and objects, to avoid recreating and altering the platform.
By default, state information is stored in a local file terraform.tfstate, but if necessary, remote storage can be used for team collaboration.
U kunt ook de huidige bronnen van het platform importeren in de status, zodat u verder kunt samenwerken met andere bronnen die zonder Terraform zijn aangemaakt.
2. Infrastructuur creëren
Nu we de componenten hebben doorgenomen, zullen we stap voor stap de infrastructuur opzetten met Terraform, inclusief drie virtuele machines. De eerste met een nginx proxyserver, de tweede met opslag op basis van Nextcloud en de derde met de CMS Bitrix.
We zullen code schrijven en deze uitvoeren aan de hand van ons . Gebruikers krijgen een account met de rechten van Organization Administrator. Als u een account met dezelfde rechten in een andere VMware-cloud gebruikt, kunt u de code uit onze voorbeelden reproduceren. Laten we beginnen!
Laten we eerst een directory voor ons nieuwe project aanmaken, waar de bestanden met de infrastructuurbeschrijving worden geplaatst.
mkdir project01
Vervolgens beschrijven we de componenten van de infrastructuur. Terraform creëert verbindingen en verwerkt bestanden op basis van beschrijvingen in die bestanden. De bestanden kunnen worden genoemd op basis van het doel van de beschreven blokken, bijvoorbeeld network.tf — beschrijft de netwerkparameters voor de infrastructuur.
Voor de beschrijving van de componenten van onze infrastructuur hebben we de volgende bestanden aangemaakt:
Lijst van bestanden.
main.tf — beschrijving van de parameters voor de virtuele omgeving — virtuele machines, virtuele containers;
network.tf — beschrijving van de parameters van het virtuele netwerk en regels voor NAT, Firewall;
variables.tf — lijst van variabelen die we gebruiken;
vcd.tfvars — waarden van projectvariabelen voor de module VMware vCloud Director.
De configuratietaal in Terraform is declaratief, en de volgorde van de blokken is niet van belang, behalve voor de provisioner-blokken, want in dit blok beschrijven we de commando's die moeten worden uitgevoerd tijdens de voorbereiding van de infrastructuur en deze worden in volgorde uitgevoerd.
Structuur van de blokken.
"" "" {
# Block body
= # Argument
}
Voor het beschrijven van de blokken wordt een eigen programmeertaal HCL (HashiCorp Configuration Language) gebruikt. Het is mogelijk om de infrastructuur ook met JSON te beschrijven. U kunt meer over de syntax lezen op de website van de ontwikkelaar. .
Configuratie van omgevingsvariabelen, variables.tf en vcd.tfvars
Laten we eerst twee bestanden maken die de lijst van alle gebruikte variabelen en hun waarden voor de module VMware vCloud Director beschrijven. We beginnen met het maken van het bestand variables.tf.
Inhoud van het bestand variables.tf.
variabele "vcd_org_user" {
beschrijving = "vCD Tenant User"
}
variabele "vcd_org_password" {
beschrijving = "vCD Tenant Password"
}
variabele "vcd_org" {
beschrijving = "vCD Tenant Org"
}
variabele "vcd_org_vdc" {
beschrijving = "vCD Tenant VDC"
}
variabele "vcd_org_url" {
beschrijving = "vCD Tenant URL"
}
variabele "vcd_org_max_retry_timeout" {
standaard = "60"
}
variabele "vcd_org_allow_unverified_ssl" {
standaard = "true"
}
variabele "vcd_org_edge_name" {
beschrijving = "vCD edge name"
}
variabele "vcd_org_catalog" {
beschrijving = "vCD public catalog"
}
variabele "vcd_template_os_centos7" {
beschrijving = "OS CentOS 7"
standaard = "CentOS7"
}
variabele "vcd_org_ssd_sp" {
beschrijving = "Opslagbeleid"
standaard = "Goud Opslagbeleid"
}
variabele "vcd_org_hdd_sp" {
beschrijving = "Opslagbeleid"
standaard = "Brons Opslagbeleid"
}
variabele "vcd_edge_local_subnet" {
beschrijving = "Organisatie Netwerk Subnet"
}
variabele "vcd_edge_external_ip" {
beschrijving = "Extern publiek IP"
}
variabele "vcd_edge_local_ip_nginx" {}
variabele "vcd_edge_local_ip_bitrix" {}
variabele "vcd_edge_local_ip_nextcloud" {}
variabele "vcd_edge_external_network" {}
Waarden van variabelen die we van de provider ontvangen.
vcd_org_user — gebruikersnaam met rechten als Organization Administrator,
vcd_org_password — gebruikerswachtwoord,
vcd_org — naam van de organisatie,
vcd_org_vdc — naam van het virtuele datacenter,
vcd_org_url — API URL,
vcd_org_edge_name — naam van de virtuele router,
vcd_org_catalog — naam van de catalogus met sjablonen voor virtuele machines,
vcd_edge_external_ip — openbaar IP-adres,
vcd_edge_external_network — naam van het externe netwerk,
vcd_org_hdd_sp — naam van het HDD opslagbeleid,
vcd_org_ssd_sp — naam van het SSD opslagbeleid.
En we voeren onze eigen variabelen in:
vcd_edge_local_ip_nginx — IP-adres van de virtuele machine met NGINX,
vcd_edge_local_ip_bitrix — IP-adres van de virtuele machine met 1C: Bitrix,
vcd_edge_local_ip_nextcloud — IP-adres van de virtuele machine met Nextcloud.
Met het tweede bestand creëren we en geven we variabelen op voor de module VMware vCloud Director in het bestand vcd.tfvars: Laat me herinneren dat we in ons voorbeeld gebruik maken van , als je met een andere provider werkt, vraag dan de waarden aan hem.
Inhoud van het bestand 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 = "Goud Opslagbeleid"
vcd_org_hdd_sp = "Brons Opslagbeleid"
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"
Netwerkconfiguratie, network.tf.
Omgevingsvariabelen zijn ingesteld, laten we nu het verbindingsschema voor virtuele machines configureren - we wijzen elke virtuele machine een privéadres toe en gebruiken Destination NAT om poorten naar het externe netwerk door te geven. Om de toegang tot de beheerderspoorten te beperken, stellen we de toegang alleen in voor ons IP-adres.
Netwerkstructuur voor het te creëren Terraform-platform
We creëren een virtueel organisatienetwerk met de naam net_lan01, standaardgateway: 192.168.110.254, en met het adresbereik: 192.168.110.0/24.
We beschrijven het virtuele netwerk.
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"
}
}
Laten we regels voor de firewall opstellen die de virtuele machines toegang geven tot het internet. In dit blok zullen alle virtuele middelen in de cloud toegang hebben tot het internet:
We beschrijven de regels voor toegang van VM naar het 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]
}
Door een afhankelijkheid in te stellen, zorgen we ervoor dat we beginnen met de configuratie van het blok vcdnsxvfirewallrule na het verwerken van het blok vcdnetworkrouted.net., met behulp van dependson. We gebruiken deze optie omdat sommige afhankelijkheden impliciet in de configuratie kunnen worden herkend.
Vervolgens creëren we regels om toegang te verlenen tot poorten vanuit het externe netwerk en geven we ons IP-adres op voor SSH-toegang tot de servers. Elke internetgebruiker heeft toegang tot de poorten 80 en 443 op de webserver en een gebruiker met het IP-adres 90.1.15.1 heeft toegang tot de SSH-poorten van de virtuele servers.
We staan toegang tot poorten vanuit het externe netwerk toe.
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]
}
We creëren Source NAT-regels voor toegang tot het internet vanuit de cloud-lokale netwerk:
We beschrijven de Source NAT-regels.
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]
}
En aan het einde van de netwerkconfiguratie voegen we Destination NAT-regels toe voor toegang tot diensten vanuit het externe netwerk:
We voegen Destination NAT-regels toe.
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"
origineel_adres = var.vcd_edge_external_ip
originele_poort = 443
vertaald_adres = var.vcd_edge_local_ip_nginx
vertaalde_poort = 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"
beschrijving = "NGINX HTTP"
origineel_adres = var.vcd_edge_external_ip
originele_poort = 80
vertaald_adres = var.vcd_edge_local_ip_nginx
vertaalde_poort = 80
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
We voegen een NAT-regel toe voor port forwarding naar de SSH-server onder 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"
beschrijving = "SSH NGINX"
origineel_adres = var.vcd_edge_external_ip
originele_poort = 58301
vertaald_adres = var.vcd_edge_local_ip_nginx
vertaalde_poort = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
We voegen een NAT-regel toe voor port forwarding naar de SSH-server met 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"
beschrijving = "SSH Bitrix"
origineel_adres = var.vcd_edge_external_ip
originele_poort = 58302
vertaald_adres = var.vcd_edge_local_ip_bitrix
vertaalde_poort = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
We voegen een NAT-regel toe voor port forwarding naar de SSH-server met 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"
beschrijving = "SSH Nextcloud"
origineel_adres = var.vcd_edge_external_ip
originele_poort = 58303 vertaald_adres = var.vcd_edge_local_ip_nextcloud
vertaalde_poort = 22
protocol = "tcp"
depends_on = [vcd_network_routed.net]
}
Configuratie van de virtuele omgeving main.tf
Zoals we aan het begin van het artikel hebben gepland, zullen we drie virtuele machines creëren. Ze worden voorbereid met behulp van 'Gastaanpassing'. De netwerkinstellingen worden opgegeven volgens de door ons opgegeven configuratie en het wachtwoord voor de gebruiker wordt automatisch gegenereerd.
We beschrijven de vApp waarin de virtuele machines en hun configuratie zich zullen bevinden.
Configuratie van de virtuele machines
We creëren een vApp-container. Zodat we zowel de vApp als de VM direct aan het virtuele netwerk kunnen koppelen, voegen we ook de parameter depends_on toe:
We creëren een container
resource "vcd_vapp" "vapp" {
naam = "web"
aanzetten = "true" depends_on = [vcd_network_routed.net]
}
We creëren een virtuele machine met een beschrijving
resource "vcd_vapp_vm" "nginx" {
vapp_naam = vcd_vapp.vapp.name
naam = "nginx"
catalogus_naam = var.vcd_org_catalog
sjabloon_naam = var.vcd_template_os_centos7
opslag_profiel = var.vcd_org_ssd_sp
geheugen = 8192
cpu's = 1
cpu_kernen = 1
netwerk {
type = "org"
naam = vcd_network_routed.net.name
is_primaire = true
adapter_type = "VMXNET3"
ip_toewijzing_mode = "MANUAL"
ip = var.vcd_edge_local_ip_nginx
}
override_template_disk {
bus_type = "paravirtual"
grootte_in_mb = "32768"
bus_nummer = 0
eenheid_nummer = 0
opslag_profiel = var.vcd_org_ssd_sp
}
}
Belangrijkste parameters in de VM-beschrijving:
naam — naam van de virtuele machine,
vappnaam — naam van de vApp waarin de nieuwe VM moet worden toegevoegd,
catalogusnaam / sjabloonnaam — naam van de catalogus en de naam van de virtuele machinesjabloon,
opslagprofiel — standaard opslagbeleid.
Parameters van het netwerkblok:
type — type van het aangesloten netwerk,
naam — in welk virtueel netwerk de VM is aangesloten,
isprimary — de primaire netwerkadapter,
ip_toewijzing_mode — adres toewijzingsmodus MANUAL / DHCP / POOL,
ip — IP-adres voor de virtuele machine, we geven dit handmatig op.
Het block override_template_disk:
grootteinmb — grootte van de bootdisk voor de virtuele machine
opslag_profiel — opslagbeleid voor de schijf
We creëren een tweede VM met een beschrijving van de Nextcloud-bestandopslag
resource "vcd_vapp_vm" "nextcloud" {
vapp_naam = vcd_vapp.vapp.name
naam = "nextcloud"
catalogus_naam = var.vcd_org_catalog
sjabloon_naam = var.vcd_template_os_centos7
opslag_profiel = var.vcd_org_ssd_sp
geheugen = 8192
cpu's = 1
cpu_kernen = 1
netwerk {
type = "org"
naam = vcd_network_routed.net.name
is_primaire = true
adapter_type = "VMXNET3"
ip_toewijzing_mode = "MANUAL"
ip = var.vcd_edge_local_ip_nextcloud
}
override_template_disk {
bus_type = "paravirtual"
grootte_in_mb = "32768"
bus_nummer = 0
eenheid_nummer = 0
opslag_profiel = 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 ]
}
In de sectie vcdvminternal_disk beschrijven we een nieuwe virtuele schijf die aan de virtuele machine wordt gekoppeld.
Toelichting op de sectie vcdvminternaldisk:
bustype — type schijfcontroller
sizeinmb — schijfgrootte
busnumber / unitnumber — aansluiting in de adapter
opslag_profiel — opslagbeleid voor de schijf
Laten we de laatste VM op Bitrix beschrijven
resource "vcd_vapp_vm" "bitrix" {
vapp_naam = vcd_vapp.vapp.name
name = "bitrix"
catalogus_naam = var.vcd_org_catalog
sjabloon_naam = var.vcd_template_os_centos7
opslag_profiel = var.vcd_org_ssd_sp
geheugen = 8192
cpu's = 1
cpu_kernen = 1
netwerk {
type = "org"
naam = vcd_network_routed.net.name
is_primaire = true
adapter_type = "VMXNET3"
ip_toewijzing_mode = "MANUAL"
ip = var.vcd_edge_local_ip_bitrix
}
override_template_disk {
bus_type = "paravirtual"
size_in_mb = "81920"
bus_nummer = 0
eenheid_nummer = 0
opslag_profiel = var.vcd_org_ssd_sp
}
}
Systeemupdates en installatie van extra scripts
Het netwerk is voorbereid, de virtuele machines zijn beschreven. Voor we onze infrastructuur importeren, kunnen we een initiële provisioning uitvoeren met behulp van provisioner-blokken zonder gebruik van Ansible.
Laten we bekijken hoe we het besturingssysteem kunnen bijwerken en het installatiescript van CMS Bitrix kunnen starten met behulp van een provisioner-blok.
Laten we beginnen met het installeren van de updates voor 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" ]
}
}
}
Benoeming van de componenten:
provisioner «remote-exec» — we verbinden het blok van de externe «provisioning»
In het connection-blok beschrijven we het type en de parameters voor de verbinding:
type — protocol, in ons geval SSH;
user — gebruikersnaam;
password — gebruikerswachtwoord. In ons geval verwijzen we naar de parameter vcdvappvm.nginx.customization[0].admin_password, die het gegenereerde wachtwoord voor de systeemgebruikers opslaat.
host — extern IP-adres voor verbinding;
port — poort voor verbinding, die we eerder in de DNAT-instellingen hebben aangegeven;
inline — we vermelden een lijst van commando's die zullen worden ingevoerd. De commando's worden in volgorde ingevoerd, zoals vermeld in deze sectie.
Als voorbeeld, laten we ook het installatie-script van 1C-Bitrix uitvoeren. Het resultaat van de scriptuitvoering zal beschikbaar zijn tijdens het uitvoeren van het plan. Om het script te installeren, beschrijven we eerst het blok:
Laten we de installatie van 1C-Bitrix beschrijven.
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"
]
}
En laten we direct de update van Bitrix beschrijven.
Voorbeeld van provisioning voor 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"
]
}
}
Belangrijk! Het script werkt mogelijk niet als SELinux niet vooraf is uitgeschakeld! Als u een gedetailleerd artikel over de installatie en configuratie van CMS 1C-Bitrix met behulp van bitrix-env.sh nodig heeft, kunt u .
3. Initialisatie van de infrastructuur
Initialisatie van modules en plugins
We gebruiken een eenvoudige 'gentleman’s set': een laptop met Windows 10 en de distributie van de officiële website . Laten we deze uitpakken en initialiseren met het commando: terraform.exe init
Na het beschrijven van de reken- en netwerkinfrastructuur, starten we de planning om onze configuratie te controleren, waar we kunnen zien wat er gemaakt wordt en hoe het met elkaar verbonden is.
We voeren de opdracht uit
- terraform plan -var-file=vcd.tfvars.We krijgen het resultaat
- Plan: 16 toe te voegen, 0 te wijzigen, 0 te vernietigen.Dat wil zeggen, volgens dit plan worden er 16 resources gecreëerd.We voeren het plan uit met het commando
- terraform.exe apply -var-file=vcd.tfvars.
Virtuele machines worden gemaakt, en vervolgens worden de door ons genoemde pakketten in de sectie provisioner uitgevoerd - het besturingssysteem wordt bijgewerkt en CMS Bitrix wordt geïnstalleerd.
Gegevens voor verbinding verkrijgen
Na het uitvoeren van het plan willen we de gegevens voor verbinding met de servers in tekstvorm verkrijgen, hiervoor stellen we de output-sectie als volgt in:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
En de volgende output vertelt ons het wachtwoord van de gemaakte virtuele machine:
Outputs: nginx_password = F#4u8!!N
Uiteindelijk krijgen we toegang tot de virtuele machines met het bijgewerkte besturingssysteem en de vooraf geïnstalleerde pakketten voor ons verdere werk. Alles is klaar!
Maar wat als u al een bestaande infrastructuur heeft?
3.1. Werken met Terraform met een bestaande infrastructuur
Heel eenvoudig, u kunt de huidige virtuele machines en hun vApp-containers importeren met het commando import.
Laten we de resource vAPP en de virtuele machine beschrijven.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
De volgende stap is om de eigenschappen van de vApp-resources in het formaat uit te voeren vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, waar:
vApp — de naam van de vApp;
org — de naam van de organisatie;
org_vdc — de naam van het virtuele datacenter.
Import van de eigenschappen van de vAPP-resource
Laten we de eigenschappen van de VM-resources in het formaat importeren: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, waarin:
VM — de naam van de VM;
vApp — de naam van de vApp;
org — de naam van de organisatie;
orgvdc — de naam van het virtuele datacenter.
Import is succesvol verlopen
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Aan het importeren van ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import voorbereid!
vcd_vapp_vm voorbereid voor import
vcd_vapp_vm.Zabbix: Status aan het vernieuwen... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import succesvol!
De geïmporteerde resources worden hierboven weergegeven. Deze resources zijn nu in
jouw Terraform-status en zullen vanaf nu door Terraform worden beheerd.
Nu kunnen we de nieuw geïmporteerde resource bekijken:
Geïmporteerde resource
> 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_nummer = 0
bus_type = "paravirtual"
disk_id = "2000"
iops = 0
size_in_mb = 122880
storage_profile = "Gold Storage Policy"
thin_provisioned = true
eenheid_nummer = 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
}
netwerk {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Nu is het helemaal klaar — we hebben het laatste punt (importeren in bestaande infrastructuur) behandeld en alle belangrijke aspecten van werken met Terraform doorgenomen.
Het hulpmiddel bleek erg handig en stelt je in staat om je infrastructuur als code te beschrijven, van virtuele machines van één cloudprovider tot het beschrijven van netwerkcomponenten.
De onafhankelijkheid van de omgeving maakt het mogelijk om te werken met lokale en cloudresources, en eindigt met platformbeheer. En als er een platform is dat niet wordt ondersteund en je wilt een nieuwe toevoegen, kun je je eigen provider schrijven en deze gebruiken.
Bron: habr.com
