Dans cet article, nous verrons en quoi consiste Terraform, et lancerons également progressivement notre propre infrastructure — nous préparerons trois VM à des fins différentes : proxy, stockage de fichiers et CMS.
Sur tout en détail et en trois étapes :
1. Terraform - description, avantages et composants
Terraform est un outil IaC (Infrastructure-as-Code) permettant de créer et de gérer une infrastructure virtuelle à l'aide de code.
Nous avons noté plusieurs avantages à travailler avec l'outil :
-
Vitesse de déploiement des nouveaux locataires (environnements virtuels personnalisés). En règle générale, plus il y a de nouveaux clients, plus le personnel du support technique doit effectuer de « clics » pour publier de nouvelles ressources. Avec Terraform, les utilisateurs peuvent modifier les paramètres de la machine virtuelle (par exemple, arrêter automatiquement le système d'exploitation et augmenter la partition du disque virtuel) sans avoir besoin d'assistance technique ni arrêter la machine elle-même.
-
Vérification instantanée du plan d'activation nouveau Tennant. A l'aide de la description du code de l'infrastructure, on peut immédiatement vérifier ce qui sera ajouté et dans quel ordre, ainsi que dans quel état final sera telle ou telle machine virtuelle ou réseau virtuel avec connexions aux machines virtuelles.
-
Capacité à décrire les plateformes cloud les plus populaires. Vous pouvez utiliser l'outil d'Amazon et Google Cloud, aux plates-formes privées basées sur VMware vCloud Director, offrant des services au sein de solutions IaaS, SaaS et PaaS.
-
Gérer plusieurs fournisseurs de cloud et répartissez l'infrastructure entre eux pour améliorer la tolérance aux pannes, en utilisant une configuration unique pour créer, diagnostiquer et gérer les ressources cloud.
-
Utilisation pratique pour créer des stands de démonstration pour les tests et le débogage de logiciels. Vous pouvez créer et transférer des supports pour le service de test, tester des logiciels dans différents environnements en parallèle et modifier et supprimer instantanément des ressources en créant un seul plan de création de ressources.
Terraforme "Terrarium"
Nous avons brièvement parlé des avantages de l'outil, décomposons-le maintenant en ses composants
Fournisseurs.
Dans Terraform, presque n'importe quel type d'infrastructure peut être représenté comme une ressource. La connexion entre les ressources et la plateforme API est assurée par des modules fournisseurs, qui vous permettent de créer des ressources au sein d'une plateforme spécifique, par exemple Azure ou VMware vCloud Director.
Dans le cadre du projet, vous pouvez interagir avec différents prestataires sur différentes plateformes.
Ressources (description de la ressource).
La description des ressources vous permet de gérer les composants de la plateforme, tels que les machines virtuelles ou les réseaux.
Vous pouvez créer vous-même une description de ressource pour le fournisseur VMware vCloud Director et utiliser cette description pour créer des ressources avec n'importe quel fournisseur d'hébergement qui utilise vCloud Director. Il vous suffit de modifier les paramètres d'authentification et les paramètres de connexion réseau vers le fournisseur d'hébergement requis
Fournisseurs.
Ce composant permet d'effectuer des opérations d'installation initiale et de maintenance du système d'exploitation après la création de machines virtuelles. Une fois que vous avez créé une ressource de machine virtuelle, vous pouvez utiliser des approvisionneurs pour configurer et vous connecter via SSH, mettre à jour le système d'exploitation, ainsi que télécharger et exécuter un script.
Variables d'entrée et de sortie.
Variables d'entrée - variables d'entrée pour tous les types de blocs.
Les variables de sortie vous permettent de sauvegarder des valeurs après la création de ressources et peuvent être utilisées comme variables d'entrée dans d'autres modules, par exemple dans le bloc Provisioners.
États.
Les fichiers d'états stockent des informations sur la configuration des ressources de la plateforme du fournisseur. Lors de la première création de la plateforme, il n'y a aucune information sur les ressources et avant toute opération, Terraform met à jour l'état avec l'infrastructure réelle des ressources déjà décrites.
L'objectif principal des états est de sauvegarder un ensemble d'objets de ressources déjà créées pour comparer la configuration des ressources et des objets ajoutés afin d'éviter des créations et des modifications répétées de la plate-forme.
Par défaut, les informations d'état sont stockées dans le fichier local terraform.tfstate, mais si nécessaire, il est possible d'utiliser le stockage distant pour le travail en équipe.
Vous pouvez également importer les ressources actuelles de la plate-forme dans l'état pour interagir davantage avec d'autres ressources qui ont elles-mêmes été créées sans l'aide de Terraform.
2. Création d'infrastructures
Les composants ont été triés, maintenant en utilisant Terraform nous allons progressivement créer une infrastructure avec trois machines virtuelles. Le premier avec le serveur proxy nginx installé, le second avec un stockage de fichiers basé sur Nextcloud et le troisième avec CMS Bitrix.
Nous allons écrire du code et l'exécuter en utilisant notre exemple . Nos utilisateurs reçoivent un compte avec les droits d'administrateur de l'organisation. Si vous utilisez un compte avec les mêmes droits dans un autre cloud VMware, vous pouvez reproduire le code de nos exemples. Aller!
Tout d'abord, créons un répertoire pour notre nouveau projet dans lequel seront placés les fichiers décrivant l'infrastructure.
mkdir project01
Ensuite, nous décrivons les composants de l'infrastructure. Terraform crée des relations et traite les fichiers en fonction de la description contenue dans les fichiers. Les fichiers eux-mêmes peuvent être nommés en fonction de l'objectif des blocs décrits, par exemple, network.tf - décrit les paramètres réseau de l'infrastructure.
Pour décrire les composants de notre infrastructure, nous avons créé les fichiers suivants :
Liste des fichiers.
main.tf - description des paramètres de l'environnement virtuel - machines virtuelles, conteneurs virtuels ;
network.tf - description des paramètres du réseau virtuel et des règles NAT et pare-feu ;
variables.tf - liste des variables que nous utilisons ;
vcd.tfvars - valeurs des variables de projet pour le module VMware vCloud Director.
Le langage de configuration dans Terraform est déclaratif et l'ordre des blocs n'a pas d'importance, à l'exception des blocs du provisionneur, car dans ce bloc nous décrivons les commandes à exécuter lors de la préparation de l'infrastructure et elles seront exécutées dans l'ordre.
Structure de bloc.
<BLOCK TYPE> "<BLOCK LABEL>" "<BLOCK LABEL>" {
# Block body
<IDENTIFIER> = <EXPRESSION> # Argument
}
Pour décrire les blocs, son propre langage de programmation HCL (HashiCorp Configuration Language) est utilisé ; il est possible de décrire l'infrastructure en utilisant JSON. Vous pouvez en apprendre davantage sur la syntaxe .
Configuration des variables d'environnement, variables.tf et vcd.tfvars
Tout d'abord, créons deux fichiers qui décrivent la liste de toutes les variables utilisées et leurs valeurs pour le module VMware vCloud Director. Commençons par créer le fichier variables.tf.
Contenu du fichier 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" {}
Valeurs variables que nous recevons du fournisseur.
-
vcd_org_user — nom d'utilisateur avec les droits d'administrateur de l'organisation,
-
vcd_org_password — mot de passe utilisateur,
-
vcd_org — nom de l'organisation,
-
vcd_org_vdc — nom du centre de données virtuel,
-
vcd_org_url - URL de l'API,
-
vcd_org_edge_name — nom du routeur virtuel,
-
vcd_org_catalog — nom du répertoire contenant les modèles de machines virtuelles,
-
vcd_edge_external_ip — adresse IP publique,
-
vcd_edge_external_network — nom du réseau externe,
-
vcd_org_hdd_sp — nom de la politique de stockage sur disque dur,
-
vcd_org_ssd_sp — nom de la stratégie de stockage SSD.
Et entrez nos variables :
-
vcd_edge_local_ip_nginx — Adresse IP de la machine virtuelle avec NGINX,
-
vcd_edge_local_ip_bitrix - Adresse IP de la machine virtuelle avec 1C : Bitrix,
-
vcd_edge_local_ip_nextcloud — Adresse IP de la machine virtuelle avec Nextcloud.
Avec le deuxième fichier nous créons et spécifions les variables du module VMware vCloud Director dans le fichier vcd.tfvars : Rappelons que dans notre exemple nous utilisons , si vous travaillez avec un autre fournisseur, vérifiez les valeurs auprès de lui.
Contenu du fichier vcd.tfvars.
vcd_org_url = "https://vcloud.mclouds.ru/api"
vcd_org_user = "orgadmin"
vcd_org_password = "*"
vcd = "org"
vcd_org_vdc = "orgvdc"
vcd_org_maxretry_timeout = 60
vcd_org_allow_unverified_ssl = true
vcd_org_catalog = "Templates"
vcd_templateos_centos7 = "CentOS7"
vcd_org_ssd_sp = "Gold Storage Policy"
vcd_org_hdd_sp = "Bronze Storage Policy"
vcd_org_edge_name = "MCLOUDS-EDGE"
vcd_edge_external_ip = "185.17.66.1"
vcd_edge_local_subnet = "192.168.110.0/24"
vcd_edge_local_ip_nginx = "192.168.110.1"
vcd_edge_local_ip_bitrix = "192.168.110.10"
vcd_edge_local_ip_nextcloud = "192.168.110.11"
vcd_edge_external_network = "NET-185-17-66-0"
Configuration réseau, network.tf.
Les variables d'environnement sont définies, nous allons maintenant configurer le schéma de connexion de la machine virtuelle - nous allons attribuer une adresse IP privée à chaque machine virtuelle et utiliser Destination NAT pour « transférer » les ports vers le réseau externe. Pour limiter l'accès aux ports de gestion, nous définirons l'accès uniquement pour notre adresse IP.
Schéma de réseau pour la plateforme Terraform en cours de création
Nous créons un réseau organisationnel virtuel avec le nom net_lan01, la passerelle par défaut : 192.168.110.254, et également avec l'espace d'adressage : 192.168.110.0/24.
Nous décrivons un réseau virtuel.
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"
}
}
Créons des règles de pare-feu qui permettent aux machines virtuelles d'accéder à Internet. Au sein de ce bloc, toutes les ressources virtuelles du cloud auront accès à Internet :
Nous décrivons les règles d'accès des VM à 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]
}
Après avoir établi la dépendance, après avoir traité le bloc vcdnetworkrouted.net, nous procédons à la configuration du bloc vcdnsxvfirewallrule, en utilisant dépend de. Nous utilisons cette option car certaines dépendances peuvent être reconnues implicitement dans la configuration.
Ensuite, nous créerons des règles qui permettent d'accéder aux ports depuis le réseau externe et indiquerons notre adresse IP pour la connexion via SSH aux serveurs. Tout internaute a accès aux ports 80 et 443 du serveur web, et un utilisateur avec une adresse IP 90.1.15.1 a accès aux ports SSH des serveurs virtuels.
Autoriser l'accès aux ports du réseau externe.
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]
}
Nous créons des règles Source NAT pour accéder à Internet à partir d'un réseau local cloud :
Nous décrivons les règles Source NAT.
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]
}
Et pour compléter la configuration du bloc réseau, nous ajoutons les règles Destination NAT pour accéder aux services depuis le réseau externe :
Ajout de règles NAT de destination.
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]
}
Ajoutez une règle NAT pour la traduction de port vers le serveur SSH sous 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]
}
Ajoutez une règle NAT pour la traduction de port vers le serveur SSH avec 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]
}
Ajoutez une règle NAT pour la traduction de port vers le serveur SSH avec 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]
}
Configuration de l'environnement virtuel Main.tf
Comme nous l'avions prévu au début de l'article, nous allons créer trois machines virtuelles. Ils seront préparés à l’aide de « Guest Customization ». Nous définirons les paramètres réseau en fonction des paramètres que nous avons spécifiés et le mot de passe utilisateur sera généré automatiquement.
Décrivons le vApp dans lequel seront situées les machines virtuelles et leur configuration.
Configuration de la machine virtuelle
Créons un conteneur vApp. Afin que nous puissions connecter immédiatement la vApp et la VM au réseau virtuel, nous ajoutons également le paramètre depend_on :
Créer un conteneur
resource "vcd_vapp" "vapp" {
name = "web"
power_on = "true" depends_on = [vcd_network_routed.net]
}
Créons une machine virtuelle avec une description
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
}
}
Principaux paramètres dans la description de la VM :
-
name — nom de la machine virtuelle,
-
vappname - nom du vApp auquel ajouter une nouvelle VM,
-
catalogname / templatename - nom du catalogue et nom du modèle de machine virtuelle,
-
profil de stockage - politique de stockage par défaut.
Paramètres du bloc réseau :
-
type — type de réseau connecté,
-
nom - à quel réseau virtuel connecter la VM,
-
isprimary - adaptateur réseau principal,
-
ipallocation_mode — Mode d'allocation d'adresse MANUEL/DHCP/POOL,
-
ip — Adresse IP de la machine virtuelle, nous la spécifierons manuellement.
bloc override_template_disk :
-
sizeinmb — taille du disque de démarrage pour la machine virtuelle
-
storage_profile — politique de stockage pour le disque
Créons une deuxième VM avec une description du stockage de fichiers Nextcloud
resource "vcd_vapp_vm" "nextcloud" {
vapp_name = vcd_vapp.vapp.name
name = "nextcloud"
catalog_name = var.vcd_org_catalog
template_name = var.vcd_template_os_centos7
storage_profile = var.vcd_org_ssd_sp
memory = 8192
cpus = 1
cpu_cores = 1
network {
type = "org"
name = vcd_network_routed.net.name
is_primary = true
adapter_type = "VMXNET3"
ip_allocation_mode = "MANUAL"
ip = var.vcd_edge_local_ip_nextcloud
}
override_template_disk {
bus_type = "paravirtual"
size_in_mb = "32768"
bus_number = 0
unit_number = 0
storage_profile = var.vcd_org_ssd_sp
}
}
resource "vcd_vm_internal_disk" "disk1" {
vapp_name = vcd_vapp.vapp.name
vm_name = "nextcloud"
bus_type = "paravirtual"
size_in_mb = "102400"
bus_number = 0
unit_number = 1
storage_profile = var.vcd_org_hdd_sp
allow_vm_reboot = true
depends_on = [ vcd_vapp_vm.nextcloud ]
}
Dans la section vcdvminternal_disk, nous décrirons un nouveau disque virtuel connecté à la machine virtuelle.
Explications pour le bloc vcdvminternaldisk :
-
bustype - type de contrôleur de disque
-
sizeinmb — taille du disque
-
numéro de bus / numéro d'unité - emplacement de connexion dans l'adaptateur
-
storage_profile — politique de stockage pour le disque
Décrivons la dernière VM sur 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
}
}
Mise à jour du système d'exploitation et installation de scripts supplémentaires
Le réseau est préparé, les machines virtuelles sont décrites. Avant d'importer notre infrastructure, nous pouvons effectuer le provisionnement initial à l'avance à l'aide de blocs provisioners et sans utiliser Ansible.
Voyons comment mettre à jour le système d'exploitation et exécuter le script d'installation du CMS Bitrix à l'aide du bloc provisionneur.
Tout d’abord, installons les packages de mise à jour CentOS.
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" ]
}
}
}
Désignation des composants :
-
provisioner « remote-exec » - connectez le bloc de provisionnement à distance
-
Dans le bloc de connexion, nous décrivons le type et les paramètres de la connexion :
-
type — protocole, dans notre cas SSH ;
-
utilisateur — nom d'utilisateur ;
-
mot de passe — mot de passe de l'utilisateur. Dans notre cas, nous indiquons le paramètre vcdvappvm.nginx.customization[0].admin_password, qui stocke le mot de passe généré pour l'utilisateur système.
-
hôte — adresse IP externe pour la connexion ;
-
port — port de connexion, précédemment spécifié dans les paramètres DNAT ;
-
inline - répertorie la liste des commandes qui seront saisies. Les commandes seront saisies dans l'ordre indiqué dans cette section.
À titre d'exemple, exécutons également le script d'installation de 1C-Bitrix. La sortie du résultat de l'exécution du script sera disponible pendant l'exécution du plan. Pour installer le script, nous décrivons d'abord le bloc :
Décrivons l'installation de 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"
]
}
Et nous décrirons immédiatement la mise à jour Bitrix.
Un exemple de provisionnement 1C-Bitrix.
resource "null_resource" "install_update_bitrix" {
provisioner "remote-exec" {
connection {
type = "ssh"
user = "root"
password = vcd_vapp_vm.bitrix.customization[0].admin_password
host = var.vcd_edge_external_ip
port = "58302"
timeout = "60s"
}
inline = [
"yum -y update && yum -y upgrade",
"yum -y install wget nano epel-release net-tools unzip zip",
"wget http://repos.1c-bitrix.ru/yum/bitrix-env.sh -O /tmp/bitrix-env.sh",
"chmod +x /tmp/bitrix-env.sh",
"/tmp/bitrix-env.sh"
]
}
}
Important! Le script risque de ne pas fonctionner si vous ne désactivez pas SELinux au préalable ! Si vous avez besoin d'un article détaillé sur l'installation et la configuration du CMS 1C-Bitrix à l'aide de bitrix-env.sh, vous pouvez également .
3. Initialisation de l'infrastructure
Initialisation des modules et plugins
Pour le travail, nous utilisons un simple « gentleman's kit » : un ordinateur portable avec OS Windows 10 et un kit de distribution du site officiel . Décompressons et initialisons à l'aide de la commande : terraform.exe init
Après avoir décrit l'infrastructure informatique et réseau, nous lançons la planification pour tester notre configuration, où nous pouvons voir ce qui sera créé et comment ils seront connectés les uns aux autres.
-
Exécutez la commande
- terraform plan -var-file=vcd.tfvars. -
On obtient le résultat
- Plan: 16 to add, 0 to change, 0 to destroy.Autrement dit, selon ce plan, 16 ressources seront créées. -
Nous lançons le plan sur commande
- terraform.exe apply -var-file=vcd.tfvars.
Des machines virtuelles seront créées, puis les packages que nous avons répertoriés seront exécutés dans la section fournisseur - le système d'exploitation sera mis à jour et le CMS Bitrix sera installé.
Réception des informations de connexion
Après avoir exécuté le plan, nous souhaitons recevoir les données sous forme de texte pour la connexion aux serveurs, pour cela nous formaterons la section de sortie comme suit :
output "nginxpassword" {
value = vcdvappvm.nginx.customization[0].adminpassword
}
Et le résultat suivant nous indique le mot de passe de la machine virtuelle créée :
Outputs: nginx_password = F#4u8!!N
En conséquence, nous avons accès à des machines virtuelles avec un système d'exploitation mis à jour et des packages préinstallés pour nos travaux ultérieurs. Tout est prêt !
Mais que se passe-t-il si vous disposez déjà d’une infrastructure existante ?
3.1. Travailler avec Terraform avec l'infrastructure existante
C'est simple, vous pouvez importer les machines virtuelles actuelles et leurs conteneurs vApp à l'aide de la commande import.
Décrivons la ressource vAPP et la machine virtuelle.
resource "vcd_vapp" "Monitoring" {
name = "Monitoring"
org = "mClouds"
vdc = "mClouds"
}
resource "vcd_vapp_vm" "Zabbix" {
name = "Zabbix"
org = "mClouds"
vdc = "mClouds"
vapp = "Monitoring"
}
L'étape suivante consiste à importer les propriétés des ressources vApp au format vcdvapp.<vApp> <org>.<orgvdc>.<vApp>, où:
-
vApp - nom du vApp ;
-
org – nom de l’organisation ;
-
org_vdc — nom du centre de données virtuel.
Importation des propriétés de ressources vAPP
Importons les propriétés des ressources VM au format : vcdvappvm.<VM> <org>.<orgvdc>.<vApp>.<VM>, dans lequel:
-
VM - Nom de la VM ;
-
vApp - nom du vApp ;
-
org – nom de l’organisation ;
-
orgvdc est le nom du centre de données virtuel.
L'importation a réussi
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.
Nous pouvons maintenant examiner la nouvelle ressource importée :
Ressource importée
> 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"
}
}
Nous sommes maintenant définitivement prêts - nous en avons terminé avec le dernier point (importation dans l'infrastructure existante) et avons examiné tous les principaux points du travail avec Terraform.
L'outil s'est avéré très pratique et vous permet de décrire votre infrastructure sous forme de code, depuis les machines virtuelles d'un fournisseur de cloud jusqu'à la description des ressources des composants réseau.
Dans le même temps, l'indépendance par rapport à l'environnement permet de travailler avec des ressources cloud locales et même de gérer la plateforme. Et s'il n'y a pas de plate-forme prise en charge et que vous souhaitez en ajouter une nouvelle, vous pouvez écrire votre propre fournisseur et l'utiliser.
Source: habr.com