In dit artikel zullen we kijken waar Terraform uit bestaat, en ook geleidelijk onze eigen infrastructuur lanceren — we zullen drie VM’s voorbereiden voor verschillende doeleinden: proxy, bestandsopslag en CMS.
Over alles in detail en in drie fasen:
1. Terraform - beschrijving, voordelen en componenten
Terraform is een IaC-tool (Infrastructure-as-Code) voor het bouwen en beheren van virtuele infrastructuur met behulp van code.
We hebben verschillende voordelen opgemerkt bij het werken met de tool:
-
Implementatiesnelheid van nieuwe tenants (aangepaste virtuele omgevingen). Normaal gesproken geldt dat hoe meer nieuwe klanten er zijn, hoe meer “klikken” het technisch ondersteuningspersoneel moet maken om nieuwe bronnen te publiceren. Met Terraform kunnen gebruikers de instellingen van virtuele machines wijzigen (bijvoorbeeld het besturingssysteem automatisch afsluiten en de virtuele schijfpartitie vergroten) zonder dat daarvoor technische ondersteuning nodig is of de machine zelf moet worden afgesloten.
-
Onmiddellijke verificatie van het activeringsplan nieuwe Tenant. Met behulp van de beschrijving van de infrastructuurcode kunnen we meteen controleren wat er zal worden toegevoegd en in welke volgorde, en in welke eindstatus deze of gene virtuele machine of virtueel netwerk met verbindingen met virtuele machines zal zijn.
-
Mogelijkheid om de meest populaire cloudplatforms te beschrijven. U kunt de tool gebruiken van Amazon en Google Cloud tot private platforms gebaseerd op VMware vCloud Director, die diensten aanbieden binnen IaaS-, SaaS- en PaaS-oplossingen.
-
Beheer meerdere cloudproviders en de infrastructuur onderling distribueren om de fouttolerantie te verbeteren, met behulp van één enkele configuratie voor het creëren, diagnosticeren en beheren van cloudbronnen.
-
Handig gebruik voor het maken van demostands voor het testen en debuggen van software. U kunt stands voor de testafdeling maken en overdragen, software parallel in verschillende omgevingen testen en resources direct wijzigen en verwijderen door slechts één resource-buildplan te maken
"Terrarium" Terravorm
We hebben kort gesproken over de voordelen van de tool, laten we deze nu in zijn componenten opsplitsen
Aanbieders.
In Terraform kan vrijwel elk type infrastructuur als een hulpbron worden weergegeven. De verbinding tussen resources en het API-platform wordt verzorgd door providermodules, waarmee u resources kunt creëren binnen een specifiek platform, bijvoorbeeld Azure of VMware vCloud Director.
Als onderdeel van het project kunt u communiceren met verschillende providers op verschillende platforms.
Bronnen (bronbeschrijving).
Met Beschrijving van bronnen kunt u platformcomponenten beheren, zoals virtuele machines of netwerken.
U kunt zelf een resourcebeschrijving maken voor de VMware vCloud Director-provider en deze beschrijving gebruiken om resources te maken bij elke hostingprovider die vCloud Director gebruikt. U hoeft alleen de authenticatieparameters en netwerkverbindingsparameters naar de vereiste hostingprovider te wijzigen
Voorzieningen.
Dit onderdeel maakt het mogelijk om bewerkingen uit te voeren voor de initiële installatie en het onderhoud van het besturingssysteem na het maken van virtuele machines. Nadat u een virtuele machineresource hebt gemaakt, kunt u provisioners gebruiken om te configureren en verbinding te maken via SSH, het besturingssysteem bij te werken en een script te downloaden en uit te voeren.
Invoer- en uitvoervariabelen.
Invoervariabelen - invoervariabelen voor elk bloktype.
Met uitvoervariabelen kunt u waarden opslaan na het aanmaken van resources en kunnen worden gebruikt als invoervariabelen in andere modules, bijvoorbeeld in het Provisioners-blok.
Staten.
Statusbestanden slaan informatie op over de configuratie van platformbronnen van de provider. Wanneer het platform voor het eerst wordt gemaakt, is er geen informatie over bronnen en vóór elke bewerking werkt Terraform de status bij met de echte infrastructuur van de reeds beschreven bronnen.
Het belangrijkste doel van staten is om een aantal objecten van reeds gemaakte bronnen op te slaan om de configuratie van toegevoegde bronnen en objecten te vergelijken om herhaalde creatie en wijzigingen aan het platform te voorkomen.
Standaard wordt statusinformatie opgeslagen in het lokale terraform.tfstate-bestand, maar indien nodig is het mogelijk om externe opslag te gebruiken voor teamwerk.
U kunt ook huidige platformbronnen in de status importeren om verder te communiceren met andere bronnen die op hun beurt zijn gemaakt zonder de hulp van Terraform.
2. Creëren van infrastructuur
De componenten zijn uitgezocht, nu gaan we met Terraform stapsgewijs een infrastructuur creëren met drie virtuele machines. De eerste met de nginx-proxyserver geïnstalleerd, de tweede met bestandsopslag op basis van Nextcloud en de derde met CMS Bitrix.
We zullen code schrijven en uitvoeren met behulp van ons voorbeeld . Onze gebruikers ontvangen een account met Organization Administrator-rechten.Als u een account met dezelfde rechten in een andere VMware-cloud gebruikt, kunt u de code uit onze voorbeelden reproduceren. Gaan!
Laten we eerst een map maken voor ons nieuwe project waarin bestanden worden geplaatst die de infrastructuur beschrijven.
mkdir project01
Vervolgens beschrijven we de infrastructuurcomponenten. Terraform legt relaties aan en verwerkt bestanden op basis van de beschrijving in de bestanden. De bestanden zelf kunnen een naam krijgen op basis van het doel van de beschreven blokken, bijvoorbeeld network.tf - beschrijft de netwerkparameters voor de infrastructuur.
Om de componenten van onze infrastructuur te beschrijven, hebben we de volgende bestanden gemaakt:
Lijst met bestanden.
main.tf - beschrijving van parameters voor de virtuele omgeving - virtuele machines, virtuele containers;
network.tf - beschrijving van virtuele netwerkparameters en NAT- en Firewall-regels;
variabelen.tf - lijst met variabelen die we gebruiken;
vcd.tfvars - projectvariabelewaarden voor de VMware vCloud Director-module.
De configuratietaal in Terraform is declaratief en de volgorde van de blokken doet er niet toe, behalve de provisionerblokken, omdat in dit blok beschrijven we de opdrachten die moeten worden uitgevoerd bij het voorbereiden van de infrastructuur en deze zullen in volgorde worden uitgevoerd.
Blokstructuur.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Voor het beschrijven van blokken wordt gebruik gemaakt van de eigen programmeertaal HCL (HashiCorp Configuration Language), daarnaast is het mogelijk om de infrastructuur te beschrijven met behulp van JSON. U kunt meer leren over de syntaxis .
Configuratie van omgevingsvariabelen, variabelen.tf en vcd.tfvars
Laten we eerst twee bestanden maken die de lijst met alle gebruikte variabelen en hun waarden voor de VMware vCloud Director-module beschrijven. Laten we eerst het bestand variabelen.tf maken.
Inhoud van het bestand variabelen.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" {}
Variabele waarden die wij van de aanbieder ontvangen.
-
vcd_org_user — gebruikersnaam met organisatiebeheerdersrechten,
-
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 map 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 voer onze 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 maken en specificeren we variabelen voor de VMware vCloud Director-module in het bestand vcd.tfvars: Laten we ons herinneren dat we in ons voorbeeld Als u met een andere provider werkt, controleer dan de waarden bij hen.
Inhoud van het vcd.tfvars-bestand.
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"
Netwerkconfiguratie, network.tf.
De omgevingsvariabelen zijn ingesteld, nu gaan we het verbindingsschema voor de virtuele machine instellen. We wijzen een privé-IP-adres toe aan elke virtuele machine en gebruiken Destination NAT om de poorten naar het externe netwerk door te sturen. Om de toegang tot beheerpoorten te beperken, stellen we alleen toegang in voor ons IP-adres.
Netwerkdiagram voor het Terraform-platform dat wordt gemaakt
We creëren een virtueel organisatienetwerk met de naam net_lan01, de standaardgateway: 192.168.110.254, en ook met de adresruimte: 192.168.110.0/24.
We beschrijven een virtueel 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 firewallregels maken waarmee virtuele machines toegang kunnen krijgen tot internet. Binnen dit blok hebben alle virtuele bronnen in de cloud toegang tot internet:
We beschrijven de regels voor VM-toegang tot 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]
}
Nadat we de afhankelijkheid hebben vastgesteld dat we na verwerking van het vcdnetworkrouted.net-blok doorgaan met het configureren van het vcdnsxvfirewallrule-blok, с омощью hangt af van. We gebruiken deze optie omdat sommige afhankelijkheden impliciet in de configuratie kunnen worden herkend.
Vervolgens zullen we regels maken die toegang tot poorten van het externe netwerk mogelijk maken en ons IP-adres aangeven om via SSH verbinding te maken met de servers. Elke internetgebruiker heeft toegang tot poort 80 en 443 op de webserver, en een gebruiker met een IP-adres 90.1.15.1 heeft toegang tot de SSH-poorten van de virtuele servers.
Sta toegang tot poorten vanaf 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 internet vanaf een lokaal cloudnetwerk:
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 om de configuratie van het netwerkblok te voltooien, voegen we Destination NAT-regels toe voor toegang tot services vanaf het externe netwerk:
Doel-NAT-regels toevoegen.
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]
}
Voeg een NAT-regel toe voor poortvertaling 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"
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]
}
Voeg een NAT-regel toe voor poortvertaling 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"
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]
}
Voeg een NAT-regel toe voor poortvertaling 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"
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]
}
Configuratie van de virtuele Main.tf-omgeving
Zoals we aan het begin van het artikel hadden gepland, zullen we drie virtuele machines maken. Ze worden voorbereid met behulp van "Gastaanpassing". We zullen de netwerkparameters instellen volgens de instellingen die we hebben opgegeven, en het gebruikerswachtwoord wordt automatisch gegenereerd.
Laten we de vApp beschrijven waarin de virtuele machines zich zullen bevinden en hun configuratie.
Configuratie van virtuele machines
Laten we een vApp-container maken. Zodat we de vApp en VM onmiddellijk kunnen verbinden met het virtuele netwerk, voegen we ook de parameter depend_on toe:
Maak een container
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Laten we een virtuele machine met een beschrijving maken
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
}
}
Belangrijkste parameters in de VM-beschrijving:
-
naam — naam van de virtuele machine,
-
vappname - naam van de vApp waaraan een nieuwe VM moet worden toegevoegd,
-
catalogusnaam / sjabloonnaam - catalogusnaam en sjabloonnaam van de virtuele machine,
-
opslagprofiel - standaard opslagbeleid.
Netwerkblokparameters:
-
type — type verbonden netwerk,
-
naam — met welk virtueel netwerk de VM moet worden verbonden,
-
isprimary - primaire netwerkadapter,
-
ipallocation_mode - MANUAL / DHCP / POOL-adrestoewijzingsmodus,
-
ip — IP-adres voor de virtuele machine, we zullen dit handmatig opgeven.
override_template_disk blok:
-
sizeinmb — grootte van de opstartschijf voor de virtuele machine
-
storage_profile — opslagbeleid voor de schijf
Laten we een tweede VM maken met een beschrijving van de Nextcloud-bestandsopslag
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 ]
}
In de sectie vcdvminternal_disk beschrijven we een nieuwe virtuele schijf die is verbonden met de virtuele machine.
Uitleg voor het vcdvminternaldisk-blok:
-
bustype - type schijfcontroller
-
sizeinmb — schijfgrootte
-
busnummer / unitnummer - aansluitlocatie in de adapter
-
storage_profile — opslagbeleid voor de schijf
Laten we de nieuwste VM op Bitrix beschrijven
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
}
}
Het besturingssysteem bijwerken en extra scripts installeren
Het netwerk is voorbereid, de virtuele machines worden beschreven. Voordat we onze infrastructuur importeren, kunnen we de initiële provisioning vooraf uitvoeren met behulp van provisioner-blokken en zonder gebruik te maken van Ansible.
Laten we eens kijken hoe we het besturingssysteem kunnen updaten en het CMS Bitrix-installatiescript kunnen uitvoeren met behulp van het provisioner-blok.
Laten we eerst CentOS-updatepakketten installeren.
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" ]
}
}
}
Benaming van componenten:
-
provisioner “remote-exec” - sluit het externe provisioningblok aan
-
In het verbindingsblok beschrijven we het type en de parameters voor de verbinding:
-
type — protocol, in ons geval SSH;
-
gebruiker — gebruikersnaam;
-
wachtwoord — gebruikerswachtwoord. In ons geval verwijzen we naar de parameter vcdvappvm.nginx.customization[0].admin_password, waarin het gegenereerde wachtwoord voor de systeemgebruiker wordt opgeslagen.
-
host — extern IP-adres voor verbinding;
-
poort — poort voor verbinding, die eerder was opgegeven in de DNAT-instellingen;
-
inline - vermeld de lijst met opdrachten die zullen worden ingevoerd. De opdrachten worden in de volgorde ingevoerd zoals aangegeven in deze sectie.
Laten we als voorbeeld bovendien het 1C-Bitrix-installatiescript uitvoeren. De uitvoer van het resultaat van de scriptuitvoering is beschikbaar terwijl het plan wordt uitgevoerd. 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 we zullen de Bitrix-update meteen beschrijven.
Een voorbeeld van 1C-Bitrix-inrichting.
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 u SELinux niet van tevoren uitschakelt! Als u een gedetailleerd artikel nodig heeft over het installeren en configureren van CMS 1C-Bitrix met behulp van bitrix-env.sh, kunt u dat doen .
3. Initialisatie van de infrastructuur
Initialiseren van modules en plug-ins
Voor werk gebruiken we een eenvoudige “gentleman’s kit”: een laptop met Windows 10 OS en een distributiekit van de officiële website . Laten we het uitpakken en initialiseren met behulp van de opdracht: terraform.exe init
Nadat we de computer- en netwerkinfrastructuur hebben beschreven, lanceren we de planning om onze configuratie te testen, waar we kunnen zien wat er zal worden gemaakt en hoe deze met elkaar zullen worden verbonden.
-
Voer de opdracht uit
- terraform plan -var-file=vcd.tfvars. -
Wij krijgen het resultaat
- Plan: 16 to add, 0 to change, 0 to destroy.Dat wil zeggen dat er volgens dit plan 16 bronnen zullen worden gecreëerd. -
We lanceren het plan op commando
- terraform.exe apply -var-file=vcd.tfvars.
Er zullen virtuele machines worden gemaakt en vervolgens zullen de pakketten die we hebben vermeld worden uitgevoerd binnen de provisioner-sectie - het besturingssysteem zal worden bijgewerkt en CMS Bitrix zal worden geïnstalleerd.
Verbindingsinformatie ontvangen
Na het uitvoeren van het plan willen we gegevens in tekstvorm ontvangen om verbinding te maken met de servers, hiervoor zullen we de uitvoersectie als volgt opmaken:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
En de volgende uitvoer vertelt ons het wachtwoord voor de gemaakte virtuele machine:
Outputs: nginx_password = F#4u8!!N
Als gevolg hiervan krijgen we toegang tot virtuele machines met een bijgewerkt besturingssysteem en vooraf geïnstalleerde pakketten voor ons verdere werk. Alles is klaar!
Maar wat als u al over een bestaande infrastructuur beschikt?
3.1. Terraform werken met bestaande infrastructuur
Het is eenvoudig: u kunt huidige virtuele machines en hun vApp-containers importeren met behulp van de importopdracht.
Laten we de vAPP-bron 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 het importeren van de eigenschappen van vApp-bronnen in het formaat vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, Waar:
-
vApp - vApp-naam;
-
org — naam van de organisatie;
-
org_vdc — naam van het virtuele datacenter.
Eigenschappen van vAPP-bronnen importeren
Laten we de eigenschappen van VM-bronnen in de indeling importeren: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, waarin:
-
VM - VM-naam;
-
vApp - vApp-naam;
-
org — naam van de organisatie;
-
orgvdc is de naam van het virtuele datacenter.
Het importeren is gelukt
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importing from ID "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Import prepared!
Prepared vcd_vapp_vm for import
vcd_vapp_vm.Zabbix: Refreshing state... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Import successful!
The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.
Nu kunnen we naar de nieuwe geïmporteerde bron kijken:
Geïmporteerde bron
> terraform show
...
# vcd_vapp.Monitoring:
resource "vcd_vapp" "Monitoring" {
guest_properties = {}
href = "https://vcloud.mclouds.ru/api/vApp/vapp-fe5db285-a4af-47c4-93e8-55df92f006ec"
id = "urn:vcloud:vapp:fe5db285-a4af-47c4-93e8-55df92f006ec"
ip = "allocated"
metadata = {}
name = "Monitoring"
org = "mClouds"
status = 4
status_text = "POWERED_ON"
vdc = "mClouds"
}
…
# vcd_vapp_vm.Zabbix:
resource "vcd_vapp_vm" "Zabbix" {
computer_name = "Zabbix"
cpu_cores = 1
cpus = 2
expose_hardware_virtualization = false
guest_properties = {}
hardware_version = "vmx-14"
href = "https://vcloud.mclouds.ru/api/vApp/vm-778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
id = "urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f"
internal_disk = [
{
bus_number = 0
bus_type = "paravirtual"
disk_id = "2000"
iops = 0
size_in_mb = 122880
storage_profile = "Gold Storage Policy"
thin_provisioned = true
unit_number = 0
},
]
memory = 8192
metadata = {}
name = "Zabbix"
org = "mClouds"
os_type = "centos8_64Guest"
storage_profile = "Gold Storage Policy"
vapp_name = "Monitoring"
vdc = "mClouds"
customization {
allow_local_admin_password = true
auto_generate_password = true
change_sid = false
enabled = false
force = false
join_domain = false
join_org_domain = false
must_change_password_on_first_login = false
number_of_auto_logons = 0
}
network {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Nu zijn we definitief klaar - we zijn klaar met het laatste punt (importeren in de bestaande infrastructuur) en hebben alle hoofdpunten van het werken met Terraform overwogen.
De tool bleek erg handig en stelt je in staat om je infrastructuur als code te beschrijven, beginnend bij virtuele machines van één cloudprovider tot het beschrijven van de bronnen van netwerkcomponenten.
Tegelijkertijd maakt de onafhankelijkheid van de omgeving het mogelijk om met lokale cloudbronnen te werken en zelfs het platform te beheren. En als er geen ondersteund platform is en u een nieuw platform wilt toevoegen, kunt u uw eigen provider schrijven en deze gebruiken.
Bron: www.habr.com