In diesem Artikel werden wir die Bestandteile von Terraform untersuchen und schrittweise unsere eigene Infrastruktur aufbauen. â wir bereiten drei VMs fĂŒr unterschiedliche Zwecke vor: Proxy, Dateispeicher und CMS.
Alles im Detail in drei Schritten:
1. Terraform â Beschreibung, Vorteile und Komponenten
Terraform ist ein IaC (Infrastructure-as-Code) Werkzeug zur Erstellung und Verwaltung virtueller Infrastruktur mit Code.
In der Arbeit mit dem Werkzeug haben wir mehrere Vorteile festgestellt:
Schnelligkeit beim Bereitstellen neuer Tenants (Benutzerumgebungen). Normalerweise erfordert eine gröĂere Anzahl neuer Kunden mehr âKlicksâ von den Technikern, um neue Ressourcen bereitzustellen. Mit Terraform können Benutzer die Parameter virtueller Maschinen anpassen (zum Beispiel das automatische Herunterfahren des Betriebssystems und die VergröĂerung der Partition der virtuellen Festplatte), ohne dass technische UnterstĂŒtzung erforderlich ist und ohne die Maschine selbst herunterzufahren.
Sofortige ĂberprĂŒfung des Aktivierungsplans eines neuen Tenants. Mit der Beschreibung des Infrastrukturcodes können wir sofort prĂŒfen, was und in welcher Reihenfolge hinzugefĂŒgt wird, sowie den Endzustand einer virtuellen Maschine oder eines virtuellen Netzwerks mit Verbindungen zu virtuellen Maschinen.
Die Möglichkeit, die meisten gÀngigen Cloud-Plattformen zu beschreiben. Sie können das Tool von Amazon und Google Cloud bis hin zu privaten Plattformen auf Basis von VMware vCloud Director verwenden, die IaaS-, SaaS- und PaaS-Lösungen anbieten.
Verwalten Sie mehrere Cloud-Anbieter und verteilen Sie die Infrastruktur zwischen ihnen, um die Ausfallsicherheit zu erhöhen, indem Sie eine Konfiguration zur Erstellung, Diagnose und Verwaltung cloudbasierter Ressourcen verwenden.
Benutzerfreundlichkeit zum Erstellen von DemostĂ€nden fĂŒr die Testung und Fehlersuche in Software. Sie können StĂ€nde fĂŒr die Testabteilung erstellen und bereitstellen, Software parallel in verschiedenen Umgebungen ĂŒberprĂŒfen sowie Ressourcen sofort Ă€ndern und entfernen, indem Sie lediglich einen Ressourcenaufbauplan erstellen.
«Terrarium» Terraform
Wir haben die Vorteile des Tools kurz umrissen; jetzt analysieren wir es im Detail.
Anbieter.Â
In Terraform kann praktisch jeder Infrastrukturtyp als Ressource dargestellt werden. Die Verbindung zwischen Ressourcen und der API-Plattform wird durch Provider-Module hergestellt, die es ermöglichen, Ressourcen auf einer bestimmten Plattform wie Azure oder VMware vCloud Director zu erstellen.
Im Rahmen des Projekts können Sie mit verschiedenen Anbietern auf unterschiedlichen Plattformen interagieren.
Ressourcen (Ressourcenspezifikationen).
Die Ressourcenspezifikationen ermöglichen die Verwaltung von Plattformkomponenten, wie z.B. virtuellen Maschinen oder Netzwerken.Â
Sie können die Spezifikation von Ressourcen fĂŒr den Anbieter VMware vCloud Director selbst erstellen und diese Nutzung zur Erstellung von Ressourcen bei jedem Hosting-Anbieter verwenden, der vCloud Director nutzt. Sie mĂŒssen lediglich die Authentifizierungsparameter und die Netzwerkkonfiguration fĂŒr den gewĂŒnschten Hosting-Anbieter anpassen.
Provisioner.
Diese Komponente ermöglicht die DurchfĂŒhrung von Installations- und Wartungsoperationen des Betriebssystems nach der Erstellung virtueller Maschinen. Nachdem Sie eine virtuelle Maschine erstellt haben, können Sie mit Hilfe von Provisioners die Maschine konfigurieren und sich per SSH verbinden, das Betriebssystem aktualisieren und Skripte hochladen und ausfĂŒhren.Â
Eingabe- und Ausgabevariablen.
Eingangsvariablen sind die Eingabevariablen fĂŒr alle Blocktypen.Â
Ausgabevariablen ermöglichen es, Werte nach der Erstellung von Ressourcen zu speichern und können als Eingangsvariablen in anderen Modulen verwendet werden, zum Beispiel im Block Provisioners.
ZustÀnde.
Zustandsdateien speichern Informationen ĂŒber die Konfiguration von Ressourcen der Plattform des Anbieters. Bei der ersten Erstellung der Plattform gibt es keine Informationen ĂŒber Ressourcen, und vor jeder Operation aktualisiert Terraform den Zustand mit der realen Infrastruktur bereits beschriebener Ressourcen.
Das Hauptziel der ZustĂ€nde besteht darin, die Verbindung zwischen Objekten bereits erstellter Ressourcen zu speichern, um die Konfiguration hinzugefĂŒgter Ressourcen und Objekte zu vergleichen und somit eine Wiederherstellung und Ănderungen der Plattform zu vermeiden.
Die Standardzustandsinformationen werden in der lokalen Datei terraform.tfstate gespeichert. Bei Bedarf können jedoch auch remote Speicherlösungen fĂŒr die Teamarbeit genutzt werden.
AuĂerdem können Sie aktuelle Plattformressourcen in den Zustand importieren, um mit anderen Ressourcen zu interagieren, die ohne Terraform erstellt wurden. Â
2. Erstellung der Infrastruktur
Die Komponenten sind analysiert, jetzt werden wir Schritt fĂŒr Schritt mit Terraform die Infrastruktur mit drei virtuellen Maschinen erstellen. Die erste wird einen nginx-Proxy-Server enthalten, die zweite einen Nextcloud-basierten Dateispeicher und die dritte ein CMS auf Basis von Bitrix.
Wir werden den Code schreiben und ausfĂŒhren, indem wir unser . Unsere Benutzer erhalten Konten mit den Rechten eines Organization Administrator. 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 zur Beschreibung der Infrastruktur abgelegt werden.
mkdir project01
Wir werden nun die Komponenten der Infrastruktur beschreiben. Terraform erstellt Verbindungen und verarbeitet Dateien basierend auf der Beschreibung in den Dateien. Die Dateien können je nach Zweck der beschriebenen Blöcke benannt werden, z. B. beschreibt network.tf die Netzwerkeinstellungen fĂŒr die Infrastruktur.
Zur Beschreibung der Komponenten unserer Infrastruktur haben wir folgende Dateien erstellt:
Dateiliste.
main.tf â beschreibt die Parameter fĂŒr die virtuelle Umgebung â virtuelle Maschinen, virtuelle Container;
network.tf â beschreibt die Parameter des virtuellen Netzwerks und Regeln fĂŒr NAT, Firewall;
variables.tf â Liste der verwendeten Variablen;
vcd.tfvars â Projektvariablenwerte 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 auszufĂŒhrenden Befehle zur Vorbereitung der Infrastruktur beschreiben, und diese werden in der angegebenen Reihenfolge ausgefĂŒhrt.
Blockstruktur.
"" "" {
# Block body
= # Argument
}
Zur Beschreibung der Blöcke wird eine eigene Programmiersprache HCL (HashiCorp Configuration Language) verwendet, es ist auch möglich, die Infrastruktur mithilfe von JSON zu beschreiben. Weitere Informationen zur Syntax finden Sie .
Konfiguration der Umgebungsvariablen, variables.tf und vcd.tfvars
ZunĂ€chst erstellen wir zwei Dateien, die die Liste aller verwendeten Variablen und deren Werte fĂŒr das Modul VMware vCloud Director beschreiben. Zuerst erstellen wir die Datei variables.tf.
Inhalt der Datei 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" {}
Die Werte der Variablen, die wir vom Anbieter erhalten.
vcd_org_user â Benutzername mit Rechten des Organisationsadministrators,
vcd_org_password â Benutzerpasswort,
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 â öffentlicher 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.
Mit der zweiten Datei erstellen wir Variablen fĂŒr das VMware vCloud Director-Modul in der Datei vcd.tfvars: Wir erinnern daran, dass wir in unserem Beispiel , wenn Sie mit einem anderen Anbieter arbeiten, erkundigen Sie sich nach den Werten bei diesem.Â
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-Speicherpolitik"
vcd_org_hdd_sp = "Bronze-Speicherpolitik"
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.
Umgebungsvariablen sind gesetzt, jetzt konfigurieren wir das Verbindungsdiagramm der virtuellen Maschinen â jeder virtuellen Maschine wird eine private IP-Adresse zugewiesen, und ĂŒber Destination NAT leiten wir Ports ins externe Netzwerk. Um den Zugang zu den Verwaltungsports zu beschrĂ€nken, erlauben wir nur unsere IP-Adresse.
Netzwerkdiagramm fĂŒr die zu erstellende Terraform-Plattform
Wir erstellen ein virtuelles Organisationsnetzwerk mit dem Namen net_lan01, Standardgateway: 192.168.110.254 und einem Adressraum: 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, um den virtuellen Maschinen den Zugriff auf das Internet zu ermöglichen. Innerhalb dieses Blocks haben alle virtuellen Ressourcen in der Cloud Zugriff auf das Internet:
Wir beschreiben die Regeln fĂŒr den Internetzugang der VM.
resource "vcd_nsxv_firewall_rule" "fw_internet_access" {
  edge_gateway  = var.vcdorgedgename
  name = "Internetzugang"
  source {
gateway_interfaces = ["intern"]
  }
  destination {
gateway_interfaces = ["extern"]
  }
  service {
protocol = "irgendein"
  }
  depends_on = [vcdnetworkrouted.net]
}
Durch das Setzen der AbhÀngigkeit beginnen wir mit der Konfiguration des Blocks vcdnsxvfirewallrule, nachdem der Block vcdnetworkrouted.net verarbeitet wurde., mithilfe von dependson. Wir verwenden diese Option, da einige AbhÀngigkeiten in der Konfiguration implizit erkannt werden können.
Als NĂ€chstes erstellen wir Regeln, die den Zugriff auf Ports aus dem externen Netzwerk ermöglichen und geben unsere IP-Adresse fĂŒr den SSH-Zugang zu den Servern an. Jeder Benutzer des Internets hat Zugriff auf die Ports 80 und 443 auf dem Webserver, wĂ€hrend der Benutzer mit der IP-Adresse 90.1.15.1 Zugriff auf die SSH-Ports der virtuellen Server hat.
Wir erleichtern den Zugriff auf Ports aus dem externen Netzwerk.
resource "vcd_nsxv_firewall_rule" "fwnatports" {
  edge_gateway  = var.vcd_org_edge_name
  name = "HTTPs Zugriff"
  source {
gateway_interfaces = ["extern"]
  }
  destination {
 gateway_interfaces = ["intern"]
  }
  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-Zugang"
  source {
 ip_addresses = [ "90.1.15.1" ]
  }
  destination {
 gateway_interfaces = ["intern"]
  }
  service {
protocol = "tcp"
port = "58301"
  }
  service {
protocol = "tcp"
port = "58302"
  }
  service {
protocol = "tcp"
port = "58303"
  }
  depends_on = [vcd_network_routed.net]
}
Wir erstellen Source NAT-Regeln fĂŒr den Zugriff von der Cloud-Local-Netzwerk ins Internet:
Wir beschreiben die Source NAT-Regeln.
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]
}
Zum Abschluss der Netzwerkkonfiguration fĂŒgen wir Destination-NAT-Regeln hinzu, um von auĂen auf die Dienste zugreifen zu können:
Wir fĂŒgen Destination-NAT-Regeln 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 hinzu, um Ports zum SSH-Server unter Nginx weiterzuleiten.
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 hinzu, um Ports zum SSH-Server mit 1C-Bitrix weiterzuleiten.
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 hinzu, um Ports zum SSH-Server mit Nextcloud weiterzuleiten.
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 mithilfe von âGuest Customizationâ vorbereitet. Die Netzwerkeinstellungen definieren wir gemÀà unserer Vorgaben, wĂ€hrend das Passwort des Benutzers automatisch generiert wird.
Wir beschreiben ein vApp, in dem die virtuellen Maschinen und ihre Konfigurationen enthalten sind.
Konfiguration der virtuellen Maschinen
Lassen Sie uns einen vApp-Container erstellen. Damit wir vApp und 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 einer 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
}
}
Wichtige Parameter in der VM-Beschreibung:
name â Name der virtuellen Maschine,
vappname â Name des vApps, in dem die neue VM hinzugefĂŒgt werden soll,
catalogname / templatename â Name des Katalogs und Name der Vorlage der virtuellen Maschine,
storageprofile â Standard-Speicherpolitik.
Parameter des Netzwerkblocks:
type â Art des angeschlossenen Netzwerks,
name â Mit welchem virtuellen Netzwerk die VM verbunden werden soll,
isprimary â Hauptnetzwerkanpassung,
ipallocation_mode â Adresszuweisungsmodus MANUAL / DHCP / POOL,
ip â IP-Adresse fĂŒr die virtuelle Maschine, werden wir manuell angeben.
Block override_template_disk:
sizeinmb â GröĂe des Bootlaufwerks fĂŒr die virtuelle Maschine
storage_profile â Speicherstrategie fĂŒr die Festplatte
Wir erstellen eine zweite VM mit der Beschreibung des Nextcloud-Dateispeichers
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 mit der virtuellen Maschine verbunden wird.
ErklÀrungen zum Block vcdvminternaldisk:
bustype â Typ des Festplattencontrollers
sizeinmb â GröĂe der Festplatte
busnumber / unitnumber â Anschlussposition im Adapter
storage_profile â Speicherstrategie fĂŒr die Festplatte
Lassen Sie uns die letzte VM fĂŒr Bitrix beschreiben
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
}
}
Aktualisierung des Betriebssystems und Installation zusÀtzlicher Skripte
Das Netzwerk ist vorbereitet, die virtuellen Maschinen sind beschrieben. Vor dem Import unserer Infrastruktur können wir eine erste Bereitstellung mit Hilfe von Provisioners durchfĂŒhren, ohne Ansible zu verwenden.
Wir sehen uns an, wie man das Betriebssystem aktualisiert und das Installationsskript fĂŒr CMS Bitrix mit Hilfe des Provisioner-Blocks 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 Bestandteile:
provisioner «remote-exec» â wir verbinden den Block fĂŒr das entfernte Provisioning.
Im Block connection beschreiben wir den Typ und die Parameter fĂŒr die Verbindung:
type â das Protokoll, in unserem Fall SSH;
user â der Benutzername;
password â das Benutzerpasswort. Hier beziehen wir uns auf den Parameter vcd_vapp_vm.nginx.customization[0].admin_password, der das generierte Passwort des Benutzers enthĂ€lt.
host â die öffentliche IP-Adresse fĂŒr die Verbindung;
port â der Anschluss fĂŒr die Verbindung, den wir zuvor in den DNAT-Einstellungen angegeben haben;
inline â wir listen die Befehle auf, die eingegeben werden sollen. Die Befehle werden der Reihe nach eingegeben, wie in diesem Abschnitt angegeben.
Als Beispiel werden wir zusĂ€tzlich das Installationsskript fĂŒr 1C-Bitrix ausfĂŒhren. Die Ausgabe des Skriptlaufs wird wĂ€hrend der AusfĂŒhrung des Plans verfĂŒgbar sein. Um das Skript zu installieren, beschreiben wir zuerst den Block:
Lassen Sie uns die Installation von 1C-Bitrix beschreiben.
provisioner "file" {
source = "prepare.sh"
ziel = "/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"
]
}
Lassen Sie uns das Bitrix-Update sofort beschreiben.
Beispiel fĂŒr die Bereitstellung von 1C-Bitrix.
resource "null_resource" "install_update_bitrix" {
provisioner "remote-exec" {
connection {
type = "ssh"
user = "root"
passwort = 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 könnte möglicherweise nicht funktionieren, wenn SELinux nicht vorher deaktiviert wird! Wenn Sie einen detaillierten 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 âGentlemen-Setâ: ein Laptop mit Windows 10 und eine Distribution von der offiziellen Website . Entpacken und initialisieren wir mit dem Befehl: terraform.exe init
Nach der Beschreibung der Computer- und Netzwerkinfrastruktur starten wir die Planung zur ĂberprĂŒfung unserer Konfiguration, bei der wir sehen können, was erstellt wird und wie es miteinander verbunden ist.
FĂŒhren Sie den Befehl aus
- terraform plan -var-file=vcd.tfvars.Wir erhalten das Ergebnis
- Plan: 16 zum HinzufĂŒgen, 0 zum Ăndern, 0 zum Zerstören.Das heiĂt, in diesem Plan werden 16 Ressourcen erstellt.Wir starten den Plan im Team
- terraform.exe apply -var-file=vcd.tfvars.
Virtuelle Maschinen werden erstellt, und dann werden die von uns aufgelisteten Pakete im Abschnitt Provisioner ausgefĂŒhrt â das Betriebssystem wird aktualisiert und CMS Bitrix installiert.
Daten zur Verbindung abrufen
Nach AusfĂŒhrung des Plans möchten wir die Daten fĂŒr die Verbindung zu den Servern in textlicher Form erhalten. Dazu gestalten wir den Abschnitt Output wie folgt:
output "nginxpassword" {
 value = vcdvappvm.nginx.customization[0].adminpassword
}
Der folgende Output informiert uns ĂŒber das Passwort der erstellten virtuellen Maschine:
Outputs: nginx_password = F#4u8!!N
Somit erhalten wir Zugriff auf die virtuellen Maschinen mit dem aktualisierten Betriebssystem und vorinstallierten Paketen fĂŒr unsere weitere Arbeit. Alles ist bereit!
Was ist jedoch, wenn Sie bereits ĂŒber eine bestehende Infrastruktur verfĂŒgen?
3.1. Terraform-Arbeit mit bereits bestehender Infrastruktur
Das ist einfach, Sie können die aktuellen virtuellen Maschinen und deren vApp-Container mit dem Import-Befehl importieren.
Beschreiben wir 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 zu importieren vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, wobei:
vApp â Name der vApp;
org â Name der Organisation;
org_vdc â Name des virtuellen Rechenzentrums.
Import der Eigenschaften der vApp-Ressource
Wir fĂŒhren den Import der VM-Ressourceneigenschaften im Format durch: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, in dem:
VM â Name der VM;
vApp â Name der vApp;
org â Name der Organisation;
orgvdc â Name des virtuellen Rechenzentrums.
Import erfolgreich
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importiere von ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import vorbereitet!
vcd_vapp_vm fĂŒr den Import vorbereitet
vcd_vapp_vm.Zabbix: Zustand wird aktualisiert... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import erfolgreich!
Die importierten Ressourcen sind oben aufgefĂŒhrt. Diese Ressourcen befinden sich jetzt in
Ihm Terraform-Zustand und werden 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 = "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"
}
}
Jetzt ist es endgĂŒltig bereit - wir haben den letzten Punkt (Import in die bestehende Infrastruktur) abgeschlossen und alle wichtigen Aspekte der Arbeit mit Terraform betrachtet.Â
Das Tool hat sich als Ă€uĂerst nĂŒtzlich erwiesen und ermöglicht es, Ihre Infrastruktur als Code zu beschreiben, angefangen bei virtuellen Maschinen eines Cloud-Anbieters bis hin zur Beschreibung der Ressourcen von Netzwerkkomponenten.
Die UnabhĂ€ngigkeit von der Umgebung ermöglicht es, sowohl mit lokalen als auch mit cloudbasierten Ressourcen zu arbeiten und die Plattformverwaltung abzuschlieĂen. Wenn eine unterstĂŒtzte Plattform fehlt und der Wunsch besteht, eine neue hinzuzufĂŒgen, kann man einen eigenen Provider schreiben und diesen nutzen.
Quelle: habr.com
