In diesem Artikel werden wir uns ansehen, woraus Terraform besteht, und auch schrittweise unsere eigene Infrastruktur starten - Bereiten Sie drei VMs für unterschiedliche Zwecke vor: Proxy, Dateispeicher und CMS.
Alles im Detail und in drei Schritten:
1. Terraform – Beschreibung, Vorteile und Komponenten
Terraform ist ein IaC-Tool (Infrastructure-as-Code) zum Aufbau und zur Verwaltung virtueller Infrastrukturen mithilfe von Code.
Bei der Arbeit mit dem Tool haben wir mehrere Vorteile festgestellt:
-
Die Geschwindigkeit der Bereitstellung neuer Mieter (benutzerdefinierte virtuelle Umgebungen). Normalerweise gilt: Je mehr neue Kunden es gibt, desto mehr „Klicks“ müssen die Mitarbeiter des technischen Supports machen, um neue Ressourcen zu veröffentlichen. Mit Terraform können Benutzer die Parameter virtueller Maschinen ändern (z. B. das Betriebssystem automatisch herunterfahren und die virtuelle Festplattenpartition vergrößern), ohne dass der technische Support eingeschaltet und die Maschine selbst heruntergefahren werden muss.
-
Sofortige Überprüfung des Aktivierungsplans neuer Mieter. Anhand der Beschreibung des Infrastrukturcodes können wir sofort überprüfen, was in welcher Reihenfolge hinzugefügt wird und in welchem Endzustand sich diese oder jene virtuelle Maschine oder dieses virtuelle Netzwerk mit Verbindungen zu virtuellen Maschinen befindet.
-
Fähigkeit, die beliebtesten Cloud-Plattformen zu beschreiben. Sie können das Werkzeug verwenden Von Amazon und Google Cloud bis hin zu privaten Plattformen auf Basis von VMware vCloud Director, die IaaS-, SaaS- und PaaS-Lösungen anbieten.
-
Verwalten Sie mehrere Cloud-Anbieter und verteilen Sie die Infrastruktur zwischen ihnen, um die Fehlertoleranz zu verbessern, indem Sie eine einzige Konfiguration zum Erstellen, Diagnostizieren und Verwalten von Cloud-Ressourcen verwenden.
-
Praktischer Einsatz zum Aufbau von Demoständen zum Testen und Debuggen von Software. Sie können Prüfstände für die Testabteilung erstellen und übertragen, Software parallel in verschiedenen Umgebungen testen und Ressourcen sofort ändern und löschen, indem Sie nur einen Ressourcenaufbauplan erstellen
„Terrarium“ Terraform
Wir haben kurz über die Vorteile des Tools gesprochen, nun analysieren wir es in seine Bestandteile
Anbieter (Anbieter).
In Terraform kann nahezu jede Art von Infrastruktur als Ressource dargestellt werden. Die Verbindung zwischen Ressourcen und der API-Plattform wird durch Anbietermodule bereitgestellt, die es Ihnen ermöglichen, Ressourcen innerhalb einer bestimmten Plattform wie Azure oder VMware vCloud Director zu erstellen.
Innerhalb eines Projekts können Sie mit unterschiedlichen Anbietern auf unterschiedlichen Plattformen interagieren.
Ressourcen (Beschreibung der Ressourcen).
Mithilfe der Ressourcenbeschreibung können Sie Plattformkomponenten wie virtuelle Maschinen oder Netzwerke verwalten.
Sie können selbst eine Ressourcenbeschreibung für einen VMware vCloud Director-Anbieter erstellen und diese Beschreibung verwenden, um Ressourcen für jeden Hosting-Anbieter zu erstellen, der vCloud Director verwendet. Sie müssen lediglich die Authentifizierungsparameter und Netzwerkverbindungsparameter zum gewünschten Hosting-Anbieter ändern
Versorger.
Diese Komponente ermöglicht die Durchführung von Vorgängen zur Erstinstallation und Wartung des Betriebssystems nach der Erstellung virtueller Maschinen. Sobald Sie eine virtuelle Maschinenressource erstellt haben, können Sie Provisioner zum Konfigurieren und Herstellen einer Verbindung über SSH, zum Aktualisieren des Betriebssystems sowie zum Herunterladen und Ausführen eines Skripts verwenden.
Variableneingabe und -ausgabe.
Eingabevariablen – Eingabevariablen für beliebige Blocktypen.
Ausgabevariablen ermöglichen das Speichern von Werten nach der Ressourcenerstellung und können als Eingabevariablen in anderen Modulen verwendet werden, beispielsweise im Provisioners-Block.
Zustände.
Statusdateien speichern Informationen über die Plattformressourcenkonfiguration des Anbieters. Bei der ersten Erstellung der Plattform liegen keine Informationen zu den Ressourcen vor, und vor jedem Vorgang aktualisiert Terraform den Status mit der tatsächlichen Infrastruktur der bereits beschriebenen Ressourcen.
Der Hauptzweck von Zuständen besteht darin, eine Reihe von Objekten bereits erstellter Ressourcen zu speichern, um die Konfiguration hinzugefügter Ressourcen und Objekte zu vergleichen und so eine Neuerstellung und Änderungen an der Plattform zu vermeiden.
Statusinformationen werden standardmäßig lokal in der Datei terraform.tfstate gespeichert, Sie können jedoch bei Bedarf Remote-Speicher für Teamarbeit verwenden.
Sie können auch die aktuellen Plattformressourcen in den Status importieren, um weiter mit anderen Ressourcen zu interagieren, die wiederum ohne die Hilfe von Terraform erstellt wurden.
2. Schaffung von Infrastruktur
Die Komponenten wurden demontiert, nun werden wir mit Hilfe von Terraform nach und nach eine Infrastruktur mit drei virtuellen Maschinen erstellen. Das erste mit installiertem Nginx-Proxyserver, das zweite mit Nextcloud-basiertem Dateispeicher und das dritte mit Bitrix CMS.
Wir werden Code schreiben und ihn anhand unseres Beispiels ausführen . Bei uns erhalten Benutzer ein Konto mit Organisationsadministratorrechten. Wenn Sie ein Konto mit den gleichen Rechten in einer anderen VMware-Cloud verwenden, können Sie den Code aus unseren Beispielen nachvollziehen. Gehen!
Erstellen wir zunächst ein Verzeichnis für unser neues Projekt, das Dateien enthält, die die Infrastruktur beschreiben.
mkdir project01
Anschließend beschreiben wir die Komponenten der Infrastruktur. Terraform erstellt Links und verarbeitet Dateien basierend auf der Beschreibung in den Dateien. Die Dateien selbst können nach dem Zweck der beschriebenen Blöcke benannt werden, zum Beispiel network.tf – beschreibt die Netzwerkparameter für die Infrastruktur.
Um die Komponenten unserer Infrastruktur zu beschreiben, haben wir die folgenden Dateien erstellt:
Liste der Dateien.
main.tf – Beschreibung der Parameter für die virtuelle Umgebung – virtuelle Maschinen, virtuelle Container;
network.tf – Beschreibung der virtuellen Netzwerkparameter und NAT, Firewall-Regeln;
Variables.tf – eine Liste der Variablen, die wir verwenden;
vcd.tfvars – Projektvariablenwerte für das VMware vCloud Director-Modul.
Die Konfigurationssprache in Terraform ist deklarativ und die Reihenfolge der Blöcke spielt keine Rolle, außer bei Provisioner-Blöcken, weil In diesem Block beschreiben wir die Befehle, die bei der Vorbereitung der Infrastruktur ausgeführt werden müssen, und sie werden der Reihe nach ausgeführt.
Blockstruktur.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Blöcke werden mit der eigenen Programmiersprache HCL (HashiCorp Configuration Language) beschrieben, die Infrastruktur kann mit JSON beschrieben werden. Weitere Informationen zur Syntax finden Sie unter .
Umgebungsvariablenkonfiguration, variables.tf und vcd.tfvars
Erstellen wir zunächst zwei Dateien, die die Liste aller verwendeten Variablen und deren Werte für das VMware vCloud Director-Modul beschreiben. Erstellen wir zunächst die Datei „variables.tf“.
Der 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" {}
Variable Werte, die wir vom Anbieter erhalten.
-
vcd_org_user – Benutzername mit Organisationsadministratorrechten,
-
vcd_org_password – Benutzerpasswort,
-
vcd_org – Organisationsname,
-
vcd_org_vdc – der Name des virtuellen Datenzentrums,
-
vcd_org_url – API-URL,
-
vcd_org_edge_name – Name des virtuellen Routers,
-
vcd_org_catalog – der Name des Verzeichnisses mit den Vorlagen für virtuelle Maschinen,
-
vcd_edge_external_ip – öffentliche IP-Adresse,
-
vcd_edge_external_network – der Name des externen Netzwerks,
-
vcd_org_hdd_sp – Name der HDD-Speicherrichtlinie,
-
vcd_org_ssd_sp ist der Name der SSD-Speicherrichtlinie.
Und geben Sie 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.
In der zweiten Datei erstellen und geben wir Variablen für das VMware vCloud Director-Modul in der Datei vcd.tfvars an: Denken Sie daran, dass wir in unserem Beispiel verwenden Wenn Sie mit einem anderen Anbieter zusammenarbeiten, überprüfen Sie die Werte mit diesem.
Der Inhalt der vcd.tfvars-Datei.
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 Verbindungsschema der virtuellen Maschine. Weisen Sie jeder virtuellen Maschine eine private IP-Adresse zu und verwenden Sie Destination NAT, um Ports an das externe Netzwerk „weiterzuleiten“. Um den Zugriff auf Verwaltungsports einzuschränken, legen wir den Zugriff nur für unsere IP-Adresse fest.
Netzwerkdiagramm für die erstellte Terraform-Plattform
Wir erstellen ein virtuelles Organisationsnetzwerk mit dem Namen net_lan01, dem Standard-Gateway: 192.168.110.254 und auch mit dem Adressraum: 192.168.110.0/24.
Beschreiben Sie 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"
}
}
Lassen Sie uns Regeln für die Firewall erstellen, die es Ihnen ermöglichen, virtuellen Maschinen Zugriff auf das Internet zu gewähren. Innerhalb dieses Blocks haben alle virtuellen Ressourcen in der Cloud Zugriff auf das Internet:
Wir beschreiben die Regeln für den VM-Zugriff auf das 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]
}
Nachdem wir die Abhängigkeit festgestellt haben, fahren wir nach der Verarbeitung des vcdnetworkrouted.net-Blocks mit der Konfiguration des vcdnsxvfirewallrule-Blocks fort, mit der Hilfe kommt drauf an. Wir verwenden diese Option, da einige Abhängigkeiten möglicherweise implizit in der Konfiguration erkannt werden.
Als nächstes erstellen wir Regeln, die den Zugriff auf Ports aus dem externen Netzwerk ermöglichen, und geben unsere IP-Adresse für die Verbindung über SSH zu den Servern an. Jeder Internetnutzer hat Zugriff auf die Ports 80 und 443 des Webservers und ein Benutzer mit der IP-Adresse 90.1.15.1 hat Zugriff auf die SSH-Ports der virtuellen Server.
Wir ermöglichen den Zugriff auf 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]
}
Erstellen Sie Quell-NAT-Regeln für den Zugriff auf das Internet über das lokale Cloud-Netzwerk:
Beschreiben Sie die Quell-NAT-Regeln.
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]
}
Und am Ende der Netzwerkblockkonfiguration fügen wir Ziel-NAT-Regeln für den Zugriff auf Dienste aus einem externen Netzwerk hinzu:
Ziel-NAT-Regeln hinzufügen.
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]
}
Fügen Sie eine NAT-Regel hinzu, um Ports zum SSH-Server unter Nginx zu übersetzen.
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]
}
Mit 1C-Bitrix fügen wir eine NAT-Regel für die Portübersetzung zum SSH-Server hinzu.
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]
}
Fügen Sie mit Nextcloud eine NAT-Regel hinzu, um Ports zum SSH-Server zu übersetzen.
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]
}
Konfiguration der virtuellen Umgebung main.tf
Wie wir zu Beginn des Artikels geplant haben, werden wir drei virtuelle Maschinen erstellen. Sie werden mit „Guest Customization“ vorbereitet. Wir schreiben die Netzwerkparameter gemäß den von uns angegebenen Einstellungen und das Passwort des Benutzers wird automatisch generiert.
Beschreiben wir die vApp, in der sich die virtuellen Maschinen und deren Konfiguration befinden werden.
Konfiguration der virtuellen Maschine
Lassen Sie uns einen vApp-Container erstellen. Damit wir die vApp und VM sofort mit dem virtuellen Netzwerk verbinden können, fügen wir außerdem den Parameter depend_on hinzu:
Erstellen Sie einen Container
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Erstellen Sie 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
}
}
Die wichtigsten Parameter in der Beschreibung der VM:
-
Name ist der Name der virtuellen Maschine.
-
vappname – der Name der vApp, in der eine neue VM hinzugefügt werden soll,
-
Katalogname / Vorlagenname – Katalogname und Name der Vorlage der virtuellen Maschine,
-
storageprofile – Standardspeicherrichtlinie.
Parameter des Netzwerkblocks:
-
Typ – Art des verbundenen Netzwerks,
-
Name – mit welchem virtuellen Netzwerk die VM verbunden werden soll,
-
isprimary – primärer Netzwerkadapter,
-
ipallocation_mode – MANUAL/DHCP/POOL-Adresszuweisungsmodus,
-
ip – IP-Adresse für die virtuelle Maschine, wir geben sie manuell an.
override_template_disk-Block:
-
sizeinmb – Boot-Festplattengröße für die virtuelle Maschine
-
storage_profile – Speicherrichtlinie für die Festplatte
Erstellen wir eine zweite VM mit einer 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 ist.
Erläuterungen zum vcdvminternaldisk-Block:
-
Bustyp – Typ des Festplattencontrollers
-
sizeinmb – Festplattengröße
-
Busnummer / Gerätenummer - Verbindungspunkt im Adapter
-
storage_profile – Speicherrichtlinie für die Festplatte
Beschreiben wir die letzte VM auf 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
}
}
Betriebssystem-Update und Installation zusätzlicher Skripte
Das Netzwerk ist vorbereitet, die virtuellen Maschinen werden beschrieben. Vor dem Import unserer Infrastruktur können wir eine Vorabbereitstellung mit Bereitstellungsblöcken durchführen, ohne Ansible zu verwenden.
Betrachten wir, wie Sie das Betriebssystem aktualisieren und das Bitrix CMS-Installationsskript mithilfe des Provisioner-Blocks ausführen.
Lassen Sie uns zuerst die CentOS Service Packs installieren.
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“ – verbindet den Remote-Block „provisioning“.
-
Im Verbindungsblock beschreiben wir den Typ und die Parameter für die Verbindung:
-
Typ - Protokoll, in unserem Fall SSH;
-
Benutzer – Benutzername;
-
Passwort – Passwort des Benutzers. In unserem Fall verweisen wir auf den Parameter vcdvappvm.nginx.customization[0].admin_password, der das generierte Passwort des Systembenutzers speichert.
-
Host – externe IP-Adresse für die Verbindung;
-
Port – Port für die Verbindung, der zuvor in den DNAT-Einstellungen angegeben wurde;
-
inline – listet die Liste der Befehle auf, die eingegeben werden. Die Befehle werden in der in diesem Abschnitt angegebenen Reihenfolge eingegeben.
Als Beispiel führen wir zusätzlich das 1C-Bitrix-Installationsskript aus. Die Ausgabe des Skriptausführungsergebnisses steht während der Ausführung des Plans zur Verfügung. Um das Skript zu installieren, beschreiben wir zunächst den Block:
Beschreiben wir 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 wir werden gleich das Bitrix-Update beschreiben.
Ein Beispiel für die 1C-Bitrix-Bereitstellung.
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, es sei denn, SELinux wurde zuvor deaktiviert! Wenn Sie einen ausführlichen Artikel zur Installation und Konfiguration von CMS 1C-Bitrix mit bitrix-env.sh benötigen, können Sie dies tun .
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 Distributionskit von der offiziellen Website . Entpacken und initialisieren Sie mit dem Befehl: terraform.exe init
Nachdem wir die Computer- und Netzwerkinfrastruktur beschrieben haben, beginnen wir mit der Planung zum Testen unserer Konfiguration. Dabei können wir sehen, was erstellt wird und wie alles miteinander verbunden ist.
-
Führen Sie den Befehl aus
- terraform plan -var-file=vcd.tfvars. -
Wir bekommen das Ergebnis
- Plan: 16 to add, 0 to change, 0 to destroy.Das heißt, nach diesem Plan werden 16 Ressourcen geschaffen. -
Den Plan auf Befehl starten
- terraform.exe apply -var-file=vcd.tfvars.
Es werden virtuelle Maschinen erstellt und dann werden die von uns aufgelisteten Pakete im Provisioner-Bereich ausgeführt – das Betriebssystem wird aktualisiert und CMS Bitrix wird installiert.
Verbindungsdaten abrufen
Nach der Ausführung des Plans möchten wir Daten zur Verbindung mit Servern in Textform erhalten, dazu ordnen wir den Ausgabebereich wie folgt an:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
Und die folgende Ausgabe verrät uns das Passwort der erstellten virtuellen Maschine:
Outputs: nginx_password = F#4u8!!N
Dadurch erhalten wir Zugriff auf virtuelle Maschinen mit aktualisiertem Betriebssystem und vorinstallierten Paketen für unsere weitere Arbeit. Alles ist fertig!
Was aber, wenn Sie bereits über eine bestehende Infrastruktur verfügen?
3.1. Terraform arbeitet mit vorhandener Infrastruktur
Es ist ganz einfach: Sie können aktuelle virtuelle Maschinen und ihre vApp-Container mit dem Importbefehl importieren.
Beschreiben wir die vAPP-Ressource 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, vApp-Ressourceneigenschaften in das Format zu importieren vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, wo:
-
vApp ist der Name der vApp;
-
org ist der Name der Organisation;
-
org_vdc ist der Name des virtuellen Datenzentrums.
vAPP-Ressourceneigenschaften importieren
Importieren wir die Eigenschaften von VM-Ressourcen im Format: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, indem:
-
VM – VM-Name;
-
vApp ist der Name der vApp;
-
org ist der Name der Organisation;
-
orgvdc ist der Name des virtuellen Datenzentrums.
Der Import war erfolgreich
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.
Jetzt können wir uns die neu 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 sind wir definitiv bereit – wir haben den letzten Moment (Import in eine bestehende Infrastruktur) abgeschlossen und alle wichtigen Punkte der Arbeit mit Terraform bedacht.
Das Tool erwies sich als sehr praktisch und ermöglicht es Ihnen, Ihre Infrastruktur als Code zu beschreiben, von virtuellen Maschinen eines Cloud-Anbieters bis hin zur Beschreibung der Ressourcen von Netzwerkkomponenten.
Gleichzeitig ermöglicht die Unabhängigkeit von der Umgebung die Arbeit mit lokalen Cloud-Ressourcen und schließlich die Plattformverwaltung. Und wenn es keine unterstützte Plattform gibt und Sie eine neue hinzufügen möchten, können Sie Ihren eigenen Anbieter schreiben und ihn verwenden.
Source: habr.com