Ebben a cikkben megvizsgáljuk, hogy miből áll a Terraform, és lépésről lépésre elindítjuk saját infrastruktúránkat — három VM-et készítünk különböző célokra: proxy, fájltároló és CMS.
Mindenről részletesen és három lépésben:
1. Terraform — leírás, előnyök és összetevők
A Terraform egy IaC (Infrastructure-as-Code) eszköz, amely lehetővé teszi a virtuális infrastruktúra kód alapú létrehozását és kezelését.
Az eszköz használata során több előnyt is megfigyeltünk:
Új bérlők, azaz felhasználói virtuális környezetek gyors telepítése. Általában minél több új ügyfél van, annál több "kattintásra" van szüksége a technikai támogatást nyújtó munkatársaknak az új erőforrások közzétételéhez. A Terraform segítségével a felhasználók módosíthatják a virtuális gépek paramétereit (például automatikusan kikapcsolhatják az operációs rendszert és növelhetik a virtuális lemez partícióját) a technikai támogatás bevonása nélkül, a gép leállítása nélkül. Az új bérlő aktiválási tervének azonnali ellenőrzése.
Az infrastruktúra kódjának leírása révén azonnal ellenőrizhetjük, hogy mi és milyen sorrendben kerül hozzáadásra, valamint hogy a virtuális gép vagy virtuális hálózat milyen végső állapotban lesz a virtuális gépekhez való kapcsolódásokkal együtt. Lehetőség a legnépszerűbb felhőplatformok leírására.
A legnépszerűbb felhőszolgáltatók eszközét használhatja, az Amazon és Google Cloud szolgáltatásoktól kezdve a VMware vCloud Director alapú magánplatformokig, amelyek IaaS, SaaS és PaaS megoldások keretében kínálnak szolgáltatásokat. Több felhőszolgáltató kezelése
és az infrastruktúra elosztása közöttük a megbízhatóság növelése érdekében, egyetlen konfigurációt használva a felhőerőforrások létrehozásához, diagnosztikájához és kezeléséhez. Kényelmes használat kiépítési demóstandokhoz
szoftverek teszteléséhez és hibakereséséhez. Standokat hozhat létre és adhat át a tesztelő csapat számára, párhuzamosan tesztelheti a szoftvert különböző környezetekben, valamint azonnal módosíthatja és törölheti az erőforrásokat, mindössze egy erőforrás-létrehozási terv készítésével. A Terraform „Terrárium”
Röviden bemutattuk az eszköz előnyeit, most nézzük meg az összetevőit.
Szolgáltatók.
Szolgáltatók.
A Terraform szinte bármilyen típusú infrastruktúrát erőforrásként lehet ábrázolni. Az erőforrások és az API platform közötti kapcsolatot a providers modulok biztosítják, amelyek lehetővé teszik az erőforrások létrehozását egy adott platform keretein belül, például Azure vagy VMware vCloud Director.
A projekt keretein belül különböző szolgáltatókkal interakcióba léphet különböző platformokon.
Resources (erőforrások leírása).
Az erőforrások leírása lehetővé teszi a platform komponenseinek kezelését, például virtuális gépek vagy hálózatok esetében.
Saját magának létrehozhat egy erőforrás-leírást a VMware vCloud Director szolgáltatóhoz, és ezt a leírást bármelyik h hosting szolgáltatónál felhasználhatja, amely a vCloud Directort használja. Csak az autentikációs paramétereket és a hálózati kapcsolat paramétereit kell megváltoztatnia a szükséges hosting szolgáltatóhoz.
Provisioners.
Ez az összetevő lehetővé teszi az operációs rendszer elsődleges telepítésének és karbantartásának végrehajtását virtuális gépek létrehozása után. Miután létrehozta a virtuális gép erőforrást, a provisioners segítségével beállíthatja és csatlakozhat SSH-n, frissítheti az operációs rendszert, valamint feltöltheti és futtathat egy szkriptet.
Input és Output változók.
Az Input változók — bármilyen típusú blokkok belépő változói.
Az Output változók lehetővé teszik az értékek megőrzését az erőforrások létrehozása után, és belépő változókként használhatók más modulokban, például a Provisioners blokkban.
States (állapotok).
A states fájlok tárolják a szolgáltató platform erőforrás-configurációjára vonatkozó információkat. Amikor először létrehozza a platformot, nincsenek információk az erőforrásokról, és bármilyen Terraform művelet előtt a rendszer frissíti az állapotot a már leírt erőforrásokkal rendelkező valós infrastruktúrával.
Az állapotok fő célja az, hogy megőrizzék az immár létrehozott erőforrások objektumainak összekapcsolását, hogy összehasonlíthassák az újonnan hozzáadott erőforrások és objektumok konfigurációját, ezzel elkerülve az újra létrehozást és a platform módosításait.
Az alapértelmezett állapotinformáció helyi fájlban, terraform.tfstate tárolódik, de szükség esetén van lehetőség távoli tárolásra is a csapatmunkához.
Ezen kívül importálhatja a platform aktuális erőforrásait egy állapotba, hogy további interakciót folytathasson más erőforrásokkal, amelyek viszont nem a Terraform segítségével készültek.
2. Infrastruktúra létrehozása
A komponensek áttekintése után a Terraform segítségével lépésről lépésre létrehozzuk az infrastruktúrát három virtuális géppel. Az első egy nginx proxyszolgáltatóval, a második egy Nextcloud alapú fájltárral, a harmadik pedig a Bitrix CMS-sel.
A kódot és a végrehajtását a mi . A felhasználók Organizational Administrator jogokkal kapják meg a fiókjukat; ha ugyanazzal a jogú fiókkal használja egy másik VMware felhőt, akkor képes lesz újra létrehozni a példáinkból származó kódot. Gyerünk!
Először hozzunk létre egy könyvtárat az új projektünk számára, ahol az infrastruktúra leíró fájljai lesznek elhelyezve.
mkdir project01
Ezután leírjuk az infrastruktúra elemeit. A Terraform összekapcsolja és feldolgozza a fájlokat a fájlokban található leírások alapján. A fájlokat a leírt blokkok célja szerint lehet elnevezni, például a network.tf — a hálózati paramétereket írja le az infrastruktúrához.
Az infrastruktúránk elemeinek leírásához a következő fájlokat hoztuk létre:
Fájlok listája.
main.tf — a virtuális környezet paramétereinek leírása — virtuális gépek, virtuális tárolók;
network.tf — a virtuális hálózat és a NAT, tűzfal szabályaik paramétereinek leírása;
variables.tf — az általunk használt változók listája;
vcd.tfvars — a VMware vCloud Director modul projekt változói.
A Terraform konfigurációs nyelve deklaratív, és a blokkok sorrendje nem számít, kivéve a provisioner blokkokat, mivel ebben a blokkban a infrastruktúra előkészítése során végrehajtandó parancsokat írjuk le, és ezek sorrendben kerülnek végrehajtásra.
A blokkok struktúrája.
"" "" {
# Block body
= # Argumentum
}
A blokkok leírásához a HCL (HashiCorp Configuration Language) saját programozási nyelvét használják, és az infrastruktúra leírása JSON segítségével is lehetséges. A szintaxisról bővebben .
Környezetváltozó konfiguráció, variables.tf és vcd.tfvars
Először létrehozunk két fájlt, amelyek leírják az összes használt változót és azok értékeit a VMware vCloud Director modulhoz. Először a variables.tf fájlt hozzuk létre.
A variables.tf fájl tartalma.
változó "vcd_org_user" {
leírás = "vCD Bérlői Felhasználó"
}
változó "vcd_org_password" {
leírás = "vCD Bérlői Jelszó"
}
változó "vcd_org" {
leírás = "vCD Bérlői Szervezet"
}
változó "vcd_org_vdc" {
leírás = "vCD Bérlői VDC"
}
változó "vcd_org_url" {
leírás = "vCD Bérlői URL"
}
változó "vcd_org_max_retry_timeout" {
alapértelmezett = "60"
}
változó "vcd_org_allow_unverified_ssl" {
alapértelmezett = "true"
}
változó "vcd_org_edge_name" {
leírás = "vCD élek neve"
}
változó "vcd_org_catalog" {
leírás = "vCD nyilvános katalógus"
}
változó "vcd_template_os_centos7" {
leírás = "OS CentOS 7"
alapértelmezett = "CentOS7"
}
változó "vcd_org_ssd_sp" {
leírás = "Tárhely Politika"
alapértelmezett = "Arany Tárhely Politika"
}
változó "vcd_org_hdd_sp" {
leírás = "Tárhely Politika"
alapértelmezett = "Bronz Tárhely Politika"
}
változó "vcd_edge_local_subnet" {
leírás = "Szervezeti Hálózat Alhálózata"
}
változó "vcd_edge_external_ip" {
leírás = "Külső nyilvános IP"
}
változó "vcd_edge_local_ip_nginx" {}
változó "vcd_edge_local_ip_bitrix" {}
változó "vcd_edge_local_ip_nextcloud" {}
változó "vcd_edge_external_network" {}
A változó értékek, amelyeket a szolgáltatótól kapunk.
vcd_org_user — felhasználónév az Szervezet Adminisztrátor jogokkal,
vcd_org_password — a felhasználó jelszava,
vcd_org — a szervezet neve,
vcd_org_vdc — a virtuális adatközpont neve,
vcd_org_url — API URL,
vcd_org_edge_name — a virtuális útválasztó neve,
vcd_org_catalog — a virtuális gépek sablonjainak katalógusa,
vcd_edge_external_ip — nyilvános IP-cím,
vcd_edge_external_network — a külső hálózat neve,
vcd_org_hdd_sp — a HDD tárolási politika neve,
vcd_org_ssd_sp — az SSD tárolási politika neve.
És beírjuk a saját változóinkat:
vcd_edge_local_ip_nginx — NGINX-sel rendelkező virtuális gép IP-címe,
vcd_edge_local_ip_bitrix — 1C: Bitrix-szel rendelkező virtuális gép IP-címe,
vcd_edge_local_ip_nextcloud — Nextcloud-dal rendelkező virtuális gép IP-címe.
A második fájlban létrehozunk és megadjuk a VMware vCloud Director modul változóit a vcd.tfvars fájlban: Emlékeztetjük, hogy a példánkban mi , ha más szolgáltatóval dolgozik, kérdezze meg tőlük az értékeket.
A vcd.tfvars fájl tartalma.
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 = "Sablonok"
vcd_templateos_centos7 = "CentOS7"
vcd_org_ssd_sp = "Arany Tárhely Politika"
vcd_org_hdd_sp = "Bronz Tárhely Politika"
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"
Hálózati konfiguráció, network.tf.
A környezeti változók meg vannak adva, most beállítjuk a virtuális gépek csatlakozási séma, amelyhez minden virtuális géphez egy privát IP-cím kerül, és a Destination NAT segítségével "átirányítjuk" a portokat a külső hálózatra. A kezelői portokhoz való hozzáférés korlátozásához csak a mi IP-címünket engedélyezzük.
A létrehozott Terraform platform hálózati sémája
Létrehozunk egy virtuális szervezeti hálózatot névvel net_lan01, alapértelmezett átjáróval: 192.168.110.254, valamint címtartománnyal: 192.168.110.0/24.
Leírjuk a virtuális hálózatot.
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"
}
}
Létrehozunk tűzfal szabályokat, amelyek lehetővé teszik a virtuális gépek Internethez való hozzáférését. E blokk keretein belül minden virtuális erőforrás a felhőben hozzáférést kap az Internethez:
Leírjuk a VM-ek Internethez való hozzáférésének szabályait.
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]
}
A dependenciát beállítva, amely biztosítja, hogy a vcdnetworkrouted.net blokk feldolgozása után kezdjük meg a vcdnsxvfirewallrule blokk konfigurálását., a segítségével dependson. Használjuk ezt az opciót, mivel egyes függőségek implicit módon ismerhetők fel a konfigurációban.
Ezt követően létrehozunk olyan szabályokat, amelyek lehetővé teszik a portokhoz való hozzáférést a külső hálózatról, és megadjuk a mi IP-címünket a SSH-hoz való kapcsolódáshoz a szerverekhez. Bármely Internet felhasználó hozzáférést kap a 80-as és 443-as portokhoz a webszerveren, míg a 90.1.15.1 IP-címmel rendelkező felhasználó hozzáférést kap a virtuális szerverek SSH portjaihoz.
Lehetővé tesszük a portok külső hálózatról való hozzáférését.
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]
}
Létrehozunk Source NAT szabályokat az Internethez való hozzáféréshez a felhőalapú helyi hálózaton keresztül:
Leírjuk a Source NAT szabályokat.
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]
}
És a hálózati blokk konfigurálásának befejezéséhez hozzáadjuk a Destination NAT szabályokat a külső hálózatról elérhető szolgáltatásokhoz:
Hozzáadjuk a Destination NAT szabályokat.
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"
eredeti_cím = var.vcd_edge_external_ip
eredeti_port = 443
lefordított_cím = var.vcd_edge_local_ip_nginx
lefordított_port = 443
protokoll = "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"
leírás = "NGINX HTTP"
eredeti_cím = var.vcd_edge_external_ip
eredeti_port = 80
lefordított_cím = var.vcd_edge_local_ip_nginx
lefordított_port = 80
protokoll = "tcp"
depends_on = [vcd_network_routed.net]
}
NAT szabályt adunk hozzá az SSH-szerver portjainak Nginx alatt történő fordításához.
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"
leírás = "SSH NGINX"
eredeti_cím = var.vcd_edge_external_ip
eredeti_port = 58301
lefordított_cím = var.vcd_edge_local_ip_nginx
lefordított_port = 22
protokoll = "tcp"
depends_on = [vcd_network_routed.net]
}
NAT szabályt adunk hozzá az SSH-szerver portjainak fordításához 1C-Bitrix alatt.
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"
leírás = "SSH Bitrix"
eredeti_cím = var.vcd_edge_external_ip
eredeti_port = 58302
lefordított_cím = var.vcd_edge_local_ip_bitrix
lefordított_port = 22
protokoll = "tcp"
depends_on = [vcd_network_routed.net]
}
NAT szabályt adunk hozzá az SSH-szerver portjainak fordításához Nextcloud alatt.
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"
leírás = "SSH Nextcloud"
eredeti_cím = var.vcd_edge_external_ip
eredeti_port = 58303 lefordított_cím = var.vcd_edge_local_ip_nextcloud
lefordított_port = 22
protokoll = "tcp"
depends_on = [vcd_network_routed.net]
}
A virtuális környezet konfigurációja main.tf
Ahogy a cikk elején terveztük, három virtuális gépet hozunk létre. Ezeket a „Guest Customization” segítségével készítjük el. A hálózati beállításokat az általunk megadott konfigurációk szerint írjuk, a felhasználói jelszó automatikusan generálódik.
Leírjuk a vApp-et, amelyben a virtuális gépek és azok konfigurációi találhatók.
A virtuális gépek konfigurációja
Létrehozunk egy vApp konténert, hogy azonnal csatlakozhassuk a vApp-ot és a VM-eket a virtuális hálózathoz is, további depend_on paramétert adunk hozzá:
Konténer létrehozása
resource "vcd_vapp" "vapp" {
név = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Létrehozunk egy virtuális gépet a leírásával
resource "vcd_vapp_vm" "nginx" {
vapp_name = vcd_vapp.vapp.name
név = "nginx"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memória = 8192
cpu-k = 1
cpu_magok = 1
hálózat {
típus = "org"
név = vcd_network_routed.net.name
is_primary = true
adapter_típus = "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
}
}
A VM leírásának fő paraméterei:
név — a virtuális gép neve,
vappname — a vApp neve, amelyhez új VM-et adunk,
catalogname / templatename — a katalógus neve és a virtuális gép sablonja,
storageprofile — az alapértelmezett tárolási politika.
A hálózat blokk paraméterei:
típus — a csatlakozó hálózat típusa,
név — melyik virtuális hálózathoz csatlakozzon a VM,
isprimary — a fő hálózati adapter,
ipallocation_mode — az IP cím kiosztásának módja MANUAL / DHCP / POOL,
ip — az IP-cím a virtuális géphez, amelyet kézzel adunk meg.
Az override_template_disk blokk:
sizeinmb — a virtuális gép boot lemezének mérete
storage_profile — a lemez tárolási politikája
Létrehozunk egy második VM-et a Nextcloud fájltároló leírásával
resource "vcd_vapp_vm" "nextcloud" {
vapp_name = vcd_vapp.vapp.name
név = "nextcloud"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memória = 8192
cpu-k = 1
cpu_magok = 1
hálózat {
típus = "org"
név = vcd_network_routed.net.name
is_primary = true
adapter_típus = "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 ]
}
A vcdvminternal_disk szakaszban új virtuális lemezt írunk le, amely csatlakozik a virtuális géphez.
Magyarázat a vcdvminternaldisk blokkhoz:
bustype — lemezvezérlő típusa
sizeinmb — a lemez mérete
busnumber / unitnumber — csatlakozási hely az adapteren
storage_profile — a lemez tárolási politikája
Leírjuk az utolsó VM-et a Bitrixen
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
memória = 8192
cpu-k = 1
cpu_magok = 1
hálózat {
típus = "org"
név = vcd_network_routed.net.name
is_primary = true
adapter_típus = "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
}
}
Az operációs rendszer frissítése és kiegészítő script-ek telepítése
A hálózat elkészült, a virtuális gépek leírva vannak. Az infrastruktúránk importálása előtt előzetes provizionálást végezhetünk a provisioners blokkok segítségével Ansible használata nélkül.
Nézzük meg, hogyan frissíthetjük az operációs rendszert és futtathatjuk a CMS Bitrix telepítő scriptjét a provisioner blokk segítségével.
Először telepítsük a CentOS frissítő csomagokat.
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" ]
}
}
}
A részek megjelölése:
provisioner «remote-exec» — csatlakozunk a távoli "provizionáló" blokhoz
A connection blokkban a csatlakozás típusát és paramétereit írjuk le:
type — a protokoll, esetünkben SSH;
user — felhasználónév;
password — a felhasználó jelszava. Esetünkben a vcdvappvm.nginx.customization[0].admin_password paraméterre hivatkozunk, amely a jelszót tárolja.
host — a csatlakozáshoz szükséges külső IP-cím;
port — a csatlakozási port, amelyet korábban a DNAT beállításokban határoztunk meg;
inline — felsoroljuk a végrehajtandó parancsok listáját. A parancsokat a megadott sorrendben hajtják végre, ahogy ezt a szakaszban megadtuk.
Például, baszni fogjuk a 1C-Bitrix telepítő scriptjét. A script futásának eredménye a terv végrehajtása során lesz elérhető. A script telepítéséhez először írjuk le a blokkot:
A 1C-Bitrix telepítését írjuk le.
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"
]
}
És azonnal leírjuk a Bitrix frissítését.
1C-Bitrix provizionálási példa.
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"
]
}
}
Fontos! A script nem fog működni, ha először nem kapcsolja ki a SELinux-ot! Ha részletes cikket szeretne a CMS 1C-Bitrix telepítéséről és beállításáról a bitrix-env.sh segítségével, akkor .
3. Az infrastruktúra inicializálása
A modulok és pluginok inicializálása
A munkához egy egyszerű "úriember csomagot" használunk: laptop Windows 10 operációs rendszerrel és a hivatalos webhelyről letöltött disztribúciót . Kicsomagoljuk és inicializáljuk a következő parancs segítségével: terraform.exe init
A számítási és hálózati infrastruktúra leírása után elindítjuk a tervezést a konfigurációnk ellenőrzésére, ahol láthatjuk, hogy mi fog létrejönni és hogyan kapcsolódnak egymáshoz.
Futtassuk a parancsot
- terraform plan -var-file=vcd.tfvars.Eredményt kapunk
- Terv: 16 hozzáadni, 0 megváltoztatni, 0 eltüntetni.Tehát e terv szerint 16 erőforrást fogunk létrehozni.Elindítjuk a tervet a következő parancs segítségével
- terraform.exe apply -var-file=vcd.tfvars.
A virtuális gépek létrejönnek, majd a megadott csomagok végrehajtódnak a provisioner szekció keretein belül — az operációs rendszer frissül és telepítve lesz a CMS Bitrix.
Kapcsolódási adatok beszerzése
A terv végrehajtása után szöveges formátumban szeretnénk megkapni az adatokat a szerverekhez való csatlakozáshoz, ehhez az output szekciót a következőképpen alakítsuk:
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
És a következő kimenet azt jelzi számunkra a létrehozott virtuális gép jelszavát:
Outputs: nginx_password = F#4u8!!N
Végül hozzáférést nyerünk a frissített operációs rendszerrel és előtelepített csomagokkal rendelkező virtuális gépekhez. Minden készen áll!
De mi van, ha már van egy meglévő infrastruktúrája?
3.1. A Terraform használata már meglévő infrastruktúrával
Egyszerű, importálhatja a jelenlegi virtuális gépeket és vApp tárolóikat az import parancs segítségével.
Írjuk le a vAPP erőforrást és a virtuális gépet.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
A következő lépés az erőforrások vApp tulajdonságainak importálása a következő formátumban vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, ahol:
vApp — a vApp neve;
org — a szervezet neve;
org_vdc — a virtuális adatközpont neve.
A vAPP erőforrás tulajdonságainak importálása
Importáljuk a VM erőforrások tulajdonságait a következő formátumban: vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, amelyben:
VM — a VM neve;
vApp — a vApp neve;
org — a szervezet neve;
orgvdc — a virtuális adatközpont neve.
Az import sikeresen megtörtént
C:UsersMikhailDesktopterraform>terraform import vcd_vapp_vm.Zabbix mClouds.mClouds.Monitoring.Zabbix
vcd_vapp_vm.Zabbix: Importálás az ID-ből "mClouds.mClouds.Monitoring.Zabbix"...
vcd_vapp_vm.Zabbix: Az import előkészítve!
vcd_vapp_vm előkészítve az importálásra
vcd_vapp_vm.Zabbix: Állapot frissítése... [id=urn:vcloud:vm:778f4a89-1c8d-45b9-9d94-0472a71c4d1f]
Importálás sikeres!
Az importált erőforrások a fenti képernyőn láthatók. Ezek az erőforrások most már
a Terraform állapotában vannak, és a jövőben a Terraform által fognak kezelődni.
Most megnézhetjük az új importált erőforrást:
Importált erőforrás
> 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
}
hálózat {
adapter_type = "VMXNET3"
ip_allocation_mode = "DHCP"
is_primary = true
mac = "00:50:56:07:01:b1"
name = "MCLOUDS-LAN01"
type = "org"
}
}
Most már biztosan kész — befejeztük az utolsó dolgot (importálás a meglévő infrastruktúrába), és áttekintettük a Terraform használatának főbb pontjait.
Az eszköz nagyon kényelmesnek bizonyult, és lehetővé teszi az infrastruktúrád kód formájában történő leírását, kezdve a virtuális gépektől egy felhőszolgáltatónál egészen a hálózati összetevők erőforrásainak leírásáig.
Ezenkívül a környezettől való függetlenség lehetővé teszi a helyi és felhőalapú erőforrásokkal, valamint platformkezeléssel végzett munkát. Ha pedig nem áll rendelkezésre támogatott platform, és új hozzáadását szeretnéd, létrehozhatsz saját szolgáltatót, és felhasználhatod azt.
Forrás: habr.com
