In diesem Artikel werden wir die Bestandteile von Terraform untersuchen und Schritt fĂŒr Schritt unsere eigene Infrastruktur aufbauen. â wir bereiten drei VMs fĂŒr verschiedene Zwecke vor: Proxy, Dateispeicher und CMS.
Alles im Detail und in drei Phasen:
1. Terraform â Beschreibung, Vorteile und Komponenten
Terraform ist ein IaC (Infrastructure-as-Code) Tool zur Erstellung und Verwaltung virtueller Infrastruktur mit Hilfe von Code.
Bei der Arbeit mit dem Tool haben wir mehrere Vorteile festgestellt:
Geschwindigkeit bei der Bereitstellung neuer Mandanten (benutzerdefinierte virtuelle Umgebungen). In der Regel gilt: Je mehr neue Kunden es gibt, desto mehr "Klicks" mĂŒssen die Mitarbeiter des technischen Supports tĂ€tigen, um neue Ressourcen bereitzustellen. Mit Terraform können die Benutzer Parameter von virtuellen Maschinen Ă€ndern (z.B. das automatische Herunterfahren des Betriebssystems und das Erhöhen der Partition der virtuellen Festplatte) ohne Eingreifen des technischen Supports und ohne das Herunterfahren der Maschine selbst.
Sofortige ĂberprĂŒfung des Aktivierungsplans des neuen Mandanten. Mit der Beschreibung des Infrastrukturcodes können wir sofort ĂŒberprĂŒfen, was und in welcher Reihenfolge hinzugefĂŒgt wird, sowie in welchem Endzustand sich die jeweilige virtuelle Maschine oder das virtuelle Netzwerk mit Verbindungen zu virtuellen Maschinen befinden wird.
Die Möglichkeit, die meisten gÀngigen Cloud-Plattformen zu beschreiben. Sie können das Tool verwenden von Amazon und Google Cloud, bis hin zu privaten Plattformen auf Basis von VMware vCloud Director, die Dienste im Rahmen von IaaS-, SaaS- und PaaS-Lösungen anbieten.
Mehrere Cloud-Anbieter verwalten und die Infrastruktur zwischen ihnen verteilen, um die Ausfallsicherheit zu erhöhen, indem eine Konfiguration zur Erstellung, Diagnose und Verwaltung von Cloud-Ressourcen verwendet wird.
Benutzerfreundlichkeit zur Erstellung von DemostĂ€nden zum Testen und Debuggen von Software. Sie können StĂ€nde fĂŒr die Testabteilung erstellen und weitergeben, Software parallel in verschiedenen Umgebungen testen, sowie Ressourcen sofort Ă€ndern und löschen, indem Sie nur einen einzigen Ressourcenaufbauplan erstellen.
"Terrarium" Terraform
Wir haben kurz ĂŒber die Vorteile des Tools gesprochen, jetzt lassen Sie uns die Komponenten besprechen
Providers (Anbieter).Â
In Terraform kann praktisch jeder Infrastrukturtyp als Ressource dargestellt werden. Die Verbindung zwischen Ressourcen und der API-Plattform wird durch Provider-Module gewÀhrleistet, die es ermöglichen, Ressourcen auf einer bestimmten Plattform, z. B. Azure oder VMware vCloud Director, zu erstellen.
Im Rahmen des Projekts können Sie mit verschiedenen Anbietern auf unterschiedlichen Plattformen interagieren.
Ressourcen (Ressourcenbeschreibung).
Die Beschreibung von Ressourcen ermöglicht die Verwaltung von Komponenten der Plattform, wie z. B. virtuellen Maschinen oder Netzwerken.Â
Sie können eine Ressourcenbeschreibung fĂŒr den Anbieter VMware vCloud Director selbst erstellen und diese Beschreibung verwenden, um Ressourcen bei jedem Hosting-Anbieter, der vCloud Director nutzt, zu erstellen. Sie mĂŒssen lediglich die Authentifizierungs- und Netzwerkkonfigurationsparameter des entsprechenden Hosting-Anbieters Ă€ndern.
Provisioners.
Diese Komponente ermöglicht das DurchfĂŒhren von Operations zur Erstinstallation und Wartung des Betriebssystems nach der Erstellung von virtuellen Maschinen. Nachdem Sie die Ressource einer virtuellen Maschine erstellt haben, können Sie mit Hilfe von Provisioners SSH konfigurieren und sich verbinden, das Betriebssystem aktualisieren sowie Skripte hochladen und ausfĂŒhren.Â
Input- und Output-Variablen.
Input-Variablen sind Eingangswerte fĂŒr beliebige Blocktypen.Â
Output-Variablen ermöglichen es, Werte nach der Erstellung von Ressourcen zu speichern und können als Eingangswerte in anderen Modulen verwendet werden, z. B. im Provisioners-Block.
States (ZustÀnde).
State-Dateien speichern Informationen ĂŒber die Konfiguration der Ressourcen der Plattform des Anbieters. Bei der ersten Erstellung der Plattform gibt es keine Informationen ĂŒber die Ressourcen, und vor jeder Operation aktualisiert Terraform den Zustand mit der realen Infrastruktur der bereits beschriebenen Ressourcen.
Das Hauptziel der ZustĂ€nde ist es, die Bindung von Objekten bereits erstellter Ressourcen zu speichern, um die Konfiguration von hinzuzufĂŒgenden Ressourcen und Objekten zu vergleichen und die erneute Erstellung und Ănderungen der Plattform zu vermeiden.
Die Standardzustandsinformationen werden in einer lokalen Datei terraform.tfstate gespeichert, aber bei Bedarf gibt es die Möglichkeit, eine entfernte Speicherung fĂŒr die Zusammenarbeit im Team zu verwenden.
Sie können auch die aktuellen Ressourcen der Plattform in einen Zustand importieren, um weiterhin mit anderen Ressourcen zu interagieren, die wiederum ohne Hilfe von Terraform erstellt wurden. Â
2. Erstellung der Infrastruktur
Die Komponenten wurden besprochen, nun werden wir mit Terraform schrittweise eine Infrastruktur mit drei virtuellen Maschinen erstellen. Die erste mit einem installierten Proxy-Server nginx, die zweite mit Speicherplatz auf Basis von Nextcloud und die dritte mit dem CMS Bitrix.
Wir werden den Code schreiben und ausfĂŒhren am Beispiel unseres . Unsere Benutzer erhalten ein Konto mit den Rechten eines Organization Administrators. Wenn Sie ein Konto mit denselben Rechten in einer anderen VMware-Cloud verwenden, können Sie den Code aus unseren Beispielen reproduzieren. Los geht's!
Zuerst erstellen wir ein Verzeichnis fĂŒr unser neues Projekt, in dem die Dateien mit der Beschreibung der Infrastruktur abgelegt werden.
mkdir project01
Dann beschreiben wir die Komponenten der Infrastruktur. Terraform erstellt Verbindungen und verarbeitet die Dateien basierend auf der Beschreibung in den Dateien. Die Dateien können je nach Zielsetzung der beschriebenen Blöcke benannt werden, zum Beispiel beschreibt network.tf die Netzwerkkonfiguration fĂŒr die Infrastruktur.
FĂŒr die Beschreibung der Komponenten unserer Infrastruktur haben wir folgende Dateien erstellt:
Liste der Dateien.
main.tf â Beschreibung der Parameter fĂŒr die virtuelle Umgebung â virtuelle Maschinen, virtuelle Container;
network.tf â Beschreibung der Parameter des virtuellen Netzwerks und der NAT-, Firewall-Regeln;
variables.tf â Liste der verwendeten Variablen;
vcd.tfvars â Werte der Projektvariablen fĂŒr das Modul VMware vCloud Director.
Die Konfigurationssprache in Terraform ist deklarativ und die Reihenfolge der Blöcke spielt keine Rolle, auĂer bei den provisioner-Blöcken, da wir in diesem Block die Befehle beschreiben, die bei der Vorbereitung der Infrastruktur ausgefĂŒhrt werden sollen, und sie werden in der angegebenen Reihenfolge ausgefĂŒhrt.
Struktur der Blöcke.
"" "" {
# Block body
= # Argument
}
FĂŒr die Beschreibung der Blöcke wird eine eigene Programmiersprache verwendet, HCL (HashiCorp Configuration Language). Es ist auch möglich, die Infrastruktur mit JSON zu beschreiben. Mehr ĂŒber die Syntax kann man .
Konfiguration der Umgebungsvariablen, variables.tf und vcd.tfvars
Zuerst erstellen wir zwei Dateien, die die Liste aller verwendeten Variablen und deren Werte fĂŒr das Modul VMware vCloud Director beschreiben. Als erstes erstellen wir die Datei variables.tf.
Inhalt der Datei variables.tf.
Variable "vcd_org_user" {
  Beschreibung = "vCD Tenant User"
}
Variable "vcd_org_password" {
  Beschreibung = "vCD Tenant Password"
}
Variable "vcd_org" {
  Beschreibung = "vCD Tenant Org"
}
Variable "vcd_org_vdc" {
  Beschreibung = "vCD Tenant VDC"
}
Variable "vcd_org_url" {
  Beschreibung = "vCD Tenant URL"
}
Variable "vcd_org_max_retry_timeout" {
  Standard = "60"
}
Variable "vcd_org_allow_unverified_ssl" {
  Standard = "true"
}
Variable "vcd_org_edge_name" {
  Beschreibung = "vCD edge name"
}
Variable "vcd_org_catalog" {
  Beschreibung = "vCD public catalog"
}
Variable "vcd_template_os_centos7" {
  Beschreibung = "OS CentOS 7"
  Standard = "CentOS7"
}
Variable "vcd_org_ssd_sp" {
  Beschreibung = "Storage Policies"
  Standard = "Gold Storage Policy"
}
Variable "vcd_org_hdd_sp" {
  Beschreibung = "Storage Policies"
  Standard = "Bronze Storage Policy"
}
Variable "vcd_edge_local_subnet" {
  Beschreibung = "Organization Network Subnet"
}
Variable "vcd_edge_external_ip" {
  Beschreibung = "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" {}
Werte der Variablen, die wir vom Anbieter erhalten.
vcd_org_user â Benutzername mit Rechten des Organisationsadministrators,
vcd_org_password â Passwort des Benutzers,
vcd_org â Name der Organisation,
vcd_org_vdc â Name des virtuellen Rechenzentrums,
vcd_org_url â API URL,
vcd_org_edge_name â Name des virtuellen Routers,
vcd_org_catalog â Name des Katalogs mit Vorlagen fĂŒr virtuelle Maschinen,
vcd_edge_external_ip â Ăffentliche IP-Adresse,
vcd_edge_external_network â Name des externen Netzwerks,
vcd_org_hdd_sp â Name der HDD-Speicherpolitik,
vcd_org_ssd_sp â Name der SSD-Speicherpolitik.
Und wir geben unsere Variablen ein:
vcd_edge_local_ip_nginx â IP-Adresse der virtuellen Maschine mit NGINX,
vcd_edge_local_ip_bitrix â IP-Adresse der virtuellen Maschine mit 1C: Bitrix,
vcd_edge_local_ip_nextcloud â IP-Adresse der virtuellen Maschine mit Nextcloud.
Im zweiten Datei erstellen wir und geben die Variablen fĂŒr das VMware vCloud Director-Modul in der Datei vcd.tfvars an: Wir erinnern uns, dass wir in unserem Beispiel , verwenden. Wenn Sie mit einem anderen Anbieter arbeiten, klĂ€ren Sie die Werte bei ihm.Â
Inhalt der Datei 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"
Netzwerkkonfiguration, network.tf.
Die Umgebungsvariablen sind festgelegt, jetzt konfigurieren wir das Verbindungschema der virtuellen Maschinen â jeder virtuellen Maschine wird eine private IP-Adresse zugewiesen, und ĂŒber Destination NAT "leiten" wir die Ports ins externe Netzwerk. Um den Zugriff auf die Verwaltungsports einzuschrĂ€nken, gewĂ€hren wir nur unserer IP-Adresse Zugriff.
Das Netzwerk-Schema fĂŒr die erstellte Terraform-Plattform
Wir erstellen ein virtuelles privates Netzwerk mit dem Namen net_lan01, Standardgateway: 192.168.110.254, sowie mit folgendem Adressbereich: 192.168.110.0/24.
Wir beschreiben das virtuelle Netzwerk.
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"
  }
}
Wir erstellen Regeln fĂŒr die Firewall, die den virtuellen Maschinen den Zugang zum Internet ermöglicht. Innerhalb dieses Blocks haben alle virtuellen Ressourcen in der Cloud Zugang zum Internet:
Wir beschreiben die Regeln fĂŒr den Zugang von VM zum 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]
}
Wir setzen die AbhÀngigkeit, dass wir nach der Verarbeitung des Blocks vcdnetworkrouted.net mit der Konfiguration des Blocks vcdnsxvfirewallrule fortfahren., mithilfe von dependson. Wir nutzen diese Option, da einige AbhÀngigkeiten möglicherweise in der Konfiguration nicht offensichtlich erkannt werden können.
Als nĂ€chstes erstellen wir Regeln, die den Zugang zu den Ports aus dem externen Netzwerk erlauben, und geben unsere IP-Adresse fĂŒr den SSH-Zugang zu den Servern an. Jeder Benutzer aus dem Internet hat Zugang zu den Ports 80 und 443 auf dem Webserver, und der Benutzer mit der IP-Adresse 90.1.15.1 hat Zugang zu den SSH-Ports der virtuellen Server.
Wir erlauben den Zugang zu den Ports aus dem externen Netzwerk.
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]
}
Wir erstellen Regeln fĂŒr Source NAT, um Zugang zum Internet aus dem Cloud-LAN zu erhalten:
Wir beschreiben die Regeln fĂŒr Source NAT.
resource "vcd_nsxv_snat" "snat_local" {
edge_gateway = var.vcd_org_edge_name
  netzwerk_typ = "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]
}
Und zum Abschluss der Konfiguration des Netzwerkblocks fĂŒgen wir Regeln fĂŒr Destination NAT hinzu, um Zugang zu den Diensten aus dem externen Netzwerk zu erhalten:
Wir fĂŒgen die Regeln fĂŒr Destination NAT hinzu.
resource "vcd_nsxv_dnat" "dnat_tcp_nginx_https" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
netzwerk_typ = "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
netzwerk_typ = "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]
}
Wir fĂŒgen eine NAT-Regel zur Portweiterleitung an den SSH-Server unter Nginx hinzu.
resource "vcd_nsxv_dnat" "dnat_tcp-nginx_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
netzwerk_typ = "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]
}
Wir fĂŒgen eine NAT-Regel zur Portweiterleitung an den SSH-Server mit 1C-Bitrix hinzu.
resource "vcd_nsxv_dnat" "dnat_tcp_bitrix_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
netzwerk_typ = "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]
}
Wir fĂŒgen eine NAT-Regel zur Portweiterleitung an den SSH-Server mit Nextcloud hinzu.
resource "vcd_nsxv_dnat" "dnat_tcp_nextcloud_ssh" {
edge_gateway = var.vcd_org_edge_name
network_name = var.vcd_edge_external_network
netzwerk_typ = "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]
}
Konfiguration der virtuellen Umgebung main.tf
Wie zu Beginn des Artikels geplant, werden wir drei virtuelle Maschinen erstellen. Diese werden durch âGuest Customizationâ vorbereitet. Die Netzwerkkonfiguration werden wir entsprechend unseren angegebenen Einstellungen vornehmen, und das Passwort fĂŒr den Benutzer wird automatisch generiert.
Wir beschreiben das vApp, in dem sich die virtuellen Maschinen und ihre Konfiguration befinden.
Konfiguration der virtuellen Maschinen
Wir erstellen einen vApp-Container. Damit wir den vApp und die VM sofort mit dem virtuellen Netzwerk verbinden können, fĂŒgen wir auch den Parameter depends_on hinzu:
Wir erstellen einen Container
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Wir erstellen eine virtuelle Maschine mit Beschreibung
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
}
}
Die grundlegenden Parameter in der VM-Beschreibung:
name â Name der virtuellen Maschine,
vappname â Name der vApp, in die die neue VM hinzugefĂŒgt werden soll,
catalogname / templatename â Name des Katalogs und Name des Vorlagen der virtuellen Maschine,
storageprofile â Standard-Speicherpolitik.
Parameter des Blocks network:
type â Art des verbundenen Netzwerks,
name â An welches virtuelle Netzwerk die VM angeschlossen wird,
isprimary â primĂ€rer Netzwerkadapter,
ipallocation_mode â Adresszuweisungsmodus MANUAL / DHCP / POOL,
ip â IP-Adresse fĂŒr die virtuelle Maschine, die werden wir manuell angeben.
Block override_template_disk:
sizeinmb â GröĂe der Boot-Disk fĂŒr die virtuelle Maschine
storage_profile â Speicherpolitik fĂŒr die Disk
Wir erstellen die zweite VM mit der Beschreibung des Dateispeichers 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 ]
}
Im Abschnitt vcdvminternal_disk beschreiben wir eine neue virtuelle Festplatte, die an die virtuelle Maschine angeschlossen wird.
ErklÀrung zum Block vcdvminternaldisk:
bustype â Typ des Festplattenspeichers
sizeinmb â GröĂe der Festplatte
busnumber / unitnumber â Anschlussstelle im Adapter
storage_profile â Speicherpolitik fĂŒr die Disk
Wir beschreiben die letzte VM fĂŒr 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
}
}
Betriebssystemaktualisierung und Installation zusÀtzlicher Skripte
Das Netzwerk ist bereit, die virtuellen Maschinen sind beschrieben. Vor dem Import unserer Infrastruktur können wir eine erste Bereitstellung mit den Provisioner-Blöcken und ohne Verwendung von Ansible durchfĂŒhren.
Betrachten wir, wie man das Betriebssystem aktualisiert und das Installationsskript fĂŒr das CMS Bitrix mit Hilfe des Provisioners ausfĂŒhrt.
Zuerst fĂŒhren wir die Installation der Aktualisierungspakete fĂŒr CentOS durch.
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" ]
}
}
}
Bezeichnung der Komponenten:
provisioner «remote-exec» â blockieren wir den Block fĂŒr die remote "Provisionierung"
Im Block connection beschreiben wir Typ und Parameter fĂŒr die Verbindung:
type â Protokoll, in unserem Fall SSH;
user â Benutzername;
password â Benutzerpasswort. In unserem Fall verweisen wir auf den Parameter vcdvappvm.nginx.customization[0].admin_password, der das generierte Passwort fĂŒr den Systembenutzer speichert.
host â externe IP-Adresse fĂŒr die Verbindung;
port â Anschlussport, der zuvor in den DNAT-Einstellungen angegeben wurde;
inline â wir listen die Befehle auf, die eingegeben werden. Die Befehle werden der Reihenfolge nach ausgefĂŒhrt, wie in diesem Abschnitt angegeben.
Als Beispiel fĂŒhren wir zusĂ€tzlich das Installationsskript fĂŒr 1C-Bitrix aus. Die Ausgabe des Skriptergebnisses wird wĂ€hrend der AusfĂŒhrung des Plans verfĂŒgbar sein. Um das Skript zu installieren, beschreiben wir zuerst den Block:
Wir beschreiben die Installation von 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"
]
}
Und sofort beschreiben wir das Update fĂŒr Bitrix.
Beispiel fĂŒr die Bereitstellung von 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"
]
}
}
Wichtig! Das Skript funktioniert möglicherweise nicht, wenn SELinux nicht vorher deaktiviert wird! Wenn Sie einen ausfĂŒhrlichen Artikel zur Installation und Konfiguration von CMS 1C-Bitrix mit bitrix-env.sh benötigen, können Sie .
3. Initialisierung der Infrastruktur
Initialisierung von Modulen und Plugins
FĂŒr die Arbeit verwenden wir ein einfaches âGentleman-Setâ: einen Laptop mit Windows 10 und ein Distribution von der offiziellen Website . Entpacken und initialisieren wir mit dem Befehl: terraform.exe init
Nach der Beschreibung der Rechen- und Netzwerkstruktur starten wir die Planung, um unsere Konfiguration zu ĂŒberprĂŒfen, wo wir sehen können, was erstellt wird und wie es miteinander verbunden ist.
Wir fĂŒhren den Befehl aus
- terraform plan -var-file=vcd.tfvars.Wir erhalten das Ergebnis
- Plan: 16 hinzuzufĂŒgen, 0 zu Ă€ndern, 0 zu zerstören.Das heiĂt, nach diesem Plan werden 16 Ressourcen erstellt.Wir starten den Plan mit dem Befehl
- terraform.exe apply -var-file=vcd.tfvars.
Die virtuellen Maschinen werden erstellt, und dann werden die von uns aufgelisteten Pakete im Rahmen des Provisionierers ausgefĂŒhrt â das Betriebssystem wird aktualisiert und CMS Bitrix wird installiert.
Abrufen von Daten fĂŒr die Verbindung
Nach der AusfĂŒhrung des Plans möchten wir die Zugangsdaten fĂŒr die Server in Textform erhalten, dafĂŒr gestalten wir den Abschnitt output wie folgt:
output "nginxpassword" {
 value = vcdvappvm.nginx.customization[0].adminpassword
}
Und die nĂ€chste Ausgabe informiert uns ĂŒber das Passwort der erstellten virtuellen Maschine:
Outputs: nginx_password = F#4u8!!N
Insgesamt erhalten wir Zugriff auf die virtuellen Maschinen mit dem aktualisierten Betriebssystem und den vorinstallierten Paketen fĂŒr unsere weitere Arbeit. Alles ist bereit!
Aber was, wenn Sie bereits eine bestehende Infrastruktur haben?
3.1. Arbeiten von Terraform mit einer bestehenden Infrastruktur
Es ist ganz einfach, Sie können die aktuellen virtuellen Maschinen und deren vApp-Container mit dem Befehl importieren.
Wir beschreiben die Ressource vAPP und die virtuelle Maschine.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
Der nĂ€chste Schritt besteht darin, die Eigenschaften der vApp-Ressourcen im Format auszufĂŒhren vcdvapp. .., wo:
vApp â Name der vApp;
org â Name der Organisation;
org_vdc â Name des virtuellen Rechenzentrums.
Import der Eigenschaften der vAPP-Ressource
FĂŒhren wir den Import der Eigenschaften der VM-Ressourcen im Format aus: vcdvappvm. ..., in dem:
VM â Name der VM;
vApp â Name der vApp;
org â Name der Organisation;
orgvdc â Name des virtuellen Rechenzentrums.
Der Import war erfolgreich
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importieren von ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import vorbereitet!
vcd_vapp_vm fĂŒr den Import vorbereitet
vcd_vapp_vm.Zabbix: Status wird aktualisiert... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import erfolgreich!
Die importierten Ressourcen sind oben angezeigt. Diese Ressourcen befinden sich jetzt in
Ihrem Terraform-Zustand und werden fortan von Terraform verwaltet.
Jetzt können wir die neue importierte Ressource ansehen:
Importierte Ressource
> 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 = "zugewiesen"
metadata = {}
name = "Monitoring"
org = "mClouds"
status = 4
status_text = "EINGESCHALTET"
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"
}
}
Jetzt ist es definitiv fertig â wir haben den letzten Punkt (Import in eine bestehende Infrastruktur) abgeschlossen und alle wesentlichen Aspekte der Arbeit mit Terraform betrachtet.Â
Das Tool hat sich als sehr nĂŒtzlich erwiesen und ermöglicht es, Ihre Infrastruktur als Code zu beschreiben, angefangen bei virtuellen Maschinen eines Cloud-Anbieters bis hin zur Beschreibung von Ressourcen fĂŒr Netzwerkomponenten.
Die UnabhĂ€ngigkeit von der Umgebung ermöglicht die Arbeit mit lokalen und Cloud-Ressourcen sowie das Management von Plattformen. Wenn es keine unterstĂŒtzte Plattform gibt und der Wunsch besteht, eine neue hinzuzufĂŒgen, kann ein eigener Anbieter geschrieben und genutzt werden.
Quelle: habr.com
