diff --git a/docker/local/Dockerfile b/docker/local/Dockerfile index b5f08987..9a643e26 100644 --- a/docker/local/Dockerfile +++ b/docker/local/Dockerfile @@ -13,3 +13,4 @@ RUN yarn add @docusaurus/faster docusaurus-plugin-search-local COPY . . CMD ["yarn", "start", "--host", "0.0.0.0"] +# CMD ["sh", "-c", "yarn build && yarn serve --host 0.0.0.0 --port 3000"] # DevNote : Use this to test all translated versions diff --git a/docs/storage/oss/quickstart.md b/docs/storage/oss/quickstart.md index f57d8dd1..e7010313 100644 --- a/docs/storage/oss/quickstart.md +++ b/docs/storage/oss/quickstart.md @@ -284,7 +284,7 @@ Le Stockage Objet Cloud Temple est un service de stockage d'objets hautement sé Les associations de compte aux buckets et la configuration des restrictions d'accès sont réalisées dans l'onglet '__Politiques__' du bucket. - Cette interface vous permet de donner l'accès du compte de stockage au bucket selon quatre rôles prédéfinis (Mainteneur, Ecrivain et Lecteur, Ecrivain, Lecteur). + Cette interface vous permet de donner l'accès du compte de stockage au bucket selon quatre rôles prédéfinis (read_only, read_write, write_only, maintainer). La gestion fine des politiques d'accès via le client AWS (`put-bucket-policy`) est une opération avancée. Pour la majorité des cas d'usage, nous recommandons de passer par la console Cloud Temple pour une configuration simplifiée et sécurisée. diff --git a/docs/terraform/concepts.md b/docs/terraform/concepts.md new file mode 100644 index 00000000..42591877 --- /dev/null +++ b/docs/terraform/concepts.md @@ -0,0 +1,471 @@ +--- +title: Concepts +--- + +# Concepts de Terraform dans le provider Cloud Temple + +Cette page présente les concepts fondamentaux nécessaires pour comprendre et utiliser efficacement le provider Terraform Cloud Temple. + +## Infrastructure as Code (IaC) + +L'Infrastructure as Code est une approche qui consiste à gérer et provisionner l'infrastructure informatique à travers des fichiers de configuration lisibles par l'homme, plutôt que par une configuration manuelle ou des outils interactifs. + +### Avantages de l'IaC avec Terraform + +- **Versionnage** : L'infrastructure est définie dans des fichiers qui peuvent être versionnés (Git) +- **Collaboration** : Les équipes peuvent travailler ensemble sur la même infrastructure +- **Automatisation** : Réduction des erreurs humaines et gain de temps +- **Documentation** : Le code décrit explicitement l'infrastructure +- **Reproductibilité** : Déploiement d'environnements identiques en quelques minutes + +## Provider Terraform + +Un provider Terraform est un plugin qui permet à Terraform d'interagir avec une API spécifique. Le provider Cloud Temple agit comme une couche d'abstraction entre vos fichiers de configuration Terraform et les APIs Cloud Temple. + +### Déclaration du provider + +Le provider doit être déclaré dans un bloc `terraform` avec `required_providers` : + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Authentification + +Le provider s'authentifie auprès des APIs Cloud Temple en utilisant : + +1. **Client ID** : Identifiant unique de votre application +2. **Secret ID** : Clé secrète associée au Client ID + +Ces identifiants sont générés depuis la Console de Cloud Temple et permettent au provider d'effectuer des opérations en votre nom. + +:::info Bonnes pratiques + Stockez vos credentials dans des variables d'environnement ou un gestionnaire de secrets, jamais directement dans le code. +::: + +## Ressources + +Une ressource représente un composant d'infrastructure qui peut être créé, lu, mis à jour ou supprimé (opérations CRUD). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Types de ressources Cloud Temple + +#### IaaS VMware + +- `cloudtemple_compute_virtual_machine` : Machine virtuelle +- `cloudtemple_compute_virtual_disk` : Disque virtuel +- `cloudtemple_compute_network_adapter` : Interface réseau +- `cloudtemple_compute_virtual_controller` : Contrôleur de périphérique + +#### IaaS OpenSource + +- `cloudtemple_compute_iaas_opensource_virtual_machine` : Machine virtuelle +- `cloudtemple_compute_iaas_opensource_virtual_disk` : Disque virtuel +- `cloudtemple_compute_iaas_opensource_network_adapter` : Interface réseau +- `cloudtemple_compute_iaas_opensource_replication_policy` : Politique de réplication + +#### Object Storage + +- `cloudtemple_object_storage_bucket` : Bucket S3 +- `cloudtemple_object_storage_storage_account` : Compte de stockage +- `cloudtemple_object_storage_acl_entry` : ACL d'un bucket +- `cloudtemple_object_storage_global_access_key`: Clé d'accès global au namespace + +### Attributs et arguments + +Chaque ressource possède : + +- **Arguments** : Valeurs que vous configurez (inputs) +- **Attributs** : Valeurs retournées par la ressource (outputs) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Arguments (configuration) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Attributs (calculés automatiquement) + # id, moref, machine_manager_id, etc. +} + +# Référence à un attribut +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Les datasources permettent de récupérer des informations sur des ressources existantes sans les gérer. Elles sont en **lecture seule**. + +### Utilisation des datasources + +```hcl +# Récupération d'un datacenter existant +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Récupération d'un cluster +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Utilisation dans une ressource +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Datasources principales + +Vous pouvez retrouver la liste complète des datasources disponibles dans le provider Terraform Cloud Temple sur [documentation Terraform](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Infrastructure Compute + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Datacenter virtuel | +| `cloudtemple_compute_host_cluster` | Cluster d'hôtes | +| `cloudtemple_compute_datastore_cluster` | Cluster de datastores | +| `cloudtemple_compute_datastore` | Datastore individuel | +| `cloudtemple_compute_network` | Réseau (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates et Marketplace + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_content_library` | Bibliothèque de contenu | +| `cloudtemple_compute_content_library_item` | Item d'une bibliothèque | +| `cloudtemple_marketplace_item` | Item de la Marketplace Cloud Temple | +| `cloudtemple_compute_iaas_opensource_template` | Template dans le catalogue du IaaS OpenSource | + +#### Backup + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | Politique SLA de backup VMware | +| `cloudtemple_backup_iaas_opensource_policy` | Politique de backup OpenSource | + +#### Object Storage + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_object_storage_role` | Rôles disponibles pour les ACL | +| `cloudtemple_object_storage_bucket_files` | Fichiers dans un bucket | +| `cloudtemple_object_storage_storage_account` | Compte de stockage existant | + +## État Terraform (State) + +Le state Terraform est un fichier qui maintient la correspondance entre votre configuration et les ressources réelles dans le cloud. + +### Fichier terraform.tfstate + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Backend remote + +Pour un travail d'équipe, stockez le state dans un backend distant : + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + Le fichier `terraform.tfstate` contient des informations sensibles. Ne le commitez jamais dans Git et utilisez un backend sécurisé pour le stockage. +::: + +:::info + OpenTofu propose le chiffrement du state par défaut ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: +## Cycle de vie Terraform + +### 1. Initialisation (terraform init) + +Initialise le répertoire de travail et télécharge le provider Cloud Temple : + +```bash +terraform init +``` + +Cette commande : +- Télécharge le provider depuis le Terraform Registry +- Initialise le backend (si configuré) +- Crée le répertoire `.terraform/` + +### 2. Planification (terraform plan) + +Génère un plan d'exécution montrant les changements qui seront appliqués : + +```bash +terraform plan +``` + +Le plan indique : +- **Ressources à créer** (`+`) +- **Ressources à modifier** (`~`) +- **Ressources à détruire** (`-`) +- **Ressources à recréer** (`-/+`) + +### 3. Application (terraform apply) + +Applique les changements pour atteindre l'état désiré : + +```bash +terraform apply +``` + +Terraform : +1. Génère un plan +2. Demande confirmation (sauf avec `--auto-approve`) +3. Applique les changements +4. Met à jour le state + +### 4. Destruction (terraform destroy) + +Détruit toutes les ressources gérées : + +```bash +terraform destroy +``` + +:::danger Attention + Cette commande supprime définitivement toutes les ressources. Utilisez-la avec précaution. +::: +### 5. Autres commandes utiles + +```bash +# Afficher l'état actuel +terraform show + +# Lister les ressources +terraform state list + +# Vérifier la configuration +terraform validate + +# Formater les fichiers +terraform fmt + +# Afficher les outputs +terraform output +``` + +## Dépendances et ordre d'exécution + +Terraform analyse automatiquement les dépendances entre ressources. + +### Dépendances implicites + +Terraform détecte les références entre ressources : + +```hcl +# La datasource est évaluée en premier +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Puis la VM est créée (dépendance implicite via datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Enfin le disque est attaché (dépendance via virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Dépendances explicites + +Pour forcer un ordre spécifique, utilisez `depends_on` : + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variables et outputs + +### Variables d'entrée + +Rendent votre configuration réutilisable : + +```hcl +variable "vm_name" { + description = "Nom de la machine virtuelle" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Mémoire en GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Outputs + +Exposent des informations après l'application : + +```hcl +output "vm_id" { + description = "ID de la machine virtuelle" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "Managed Object Reference VMware" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Modules + +Les modules permettent de regrouper et réutiliser des configurations : + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Bonnes pratiques + +### Organisation des fichiers + +``` +. +├── main.tf # Ressources principales +├── variables.tf # Déclarations des variables +├── outputs.tf # Déclarations des outputs +├── versions.tf # Versions Terraform et providers +├── terraform.tfvars # Valeurs des variables (ne pas commiter) +└── modules/ # Modules réutilisables + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Gestion des secrets + +```hcl +# ❌ À éviter +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "secret-en-clair" +} + +# ✅ Recommandé +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Utilisation de tags + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Prochaines étapes + +- [Guide de démarrage](quickstart.md) : Créez votre première infrastructure avec Terraform +- [Tutoriels](tutorials.md) : Exemples pratiques pour chaque service diff --git a/docs/terraform/quickstart.md b/docs/terraform/quickstart.md new file mode 100644 index 00000000..18b441e0 --- /dev/null +++ b/docs/terraform/quickstart.md @@ -0,0 +1,565 @@ +--- +title: Guide de démarrage +--- + +# Guide de démarrage rapide + +Ce guide vous accompagne pas à pas pour déployer votre première infrastructure Cloud Temple avec Terraform. + +## Prérequis + +Avant de commencer, assurez-vous de disposer de : + +- Un compte Cloud Temple actif +- Accès à la [Console Cloud Temple](https://shiva.cloud-temple.com) +- Clé API (Client ID et Secret ID) +- Terraform installé sur votre machine (version 1.0 ou supérieure) + +## Étape 1 : Installer Terraform + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Téléchargez l'exécutable depuis [terraform.io](https://www.terraform.io/downloads) ou utilisez Chocolatey : + +```powershell +choco install terraform +``` + +### Vérification de l'installation + +```bash +terraform version +``` + +Vous devriez voir une sortie similaire à : + +``` +Terraform v1.6.0 +``` + +## Étape 2 : Obtenir votre Clé API + +### Génération d'un Clé API dans la Console + +Ces credentials peuvent être générés depuis la Console Cloud Temple en suivant [cette procédure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +:::warning Sécurité + Conservez ces credentials en lieu sûr. Le Secret ID ne sera affiché qu'une seule fois. +::: +### Configuration des variables d'environnement + +Exportez vos credentials en variables d'environnement : + +**Linux/macOS :** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell) :** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Étape 3 : Créer votre projet Terraform + +### Créer le répertoire du projet + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Créer le fichier de configuration du provider + +Créez un fichier `versions.tf` : + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Les credentials sont automatiquement récupérés depuis les variables d'environnement + # CLOUDTEMPLE_CLIENT_ID et CLOUDTEMPLE_SECRET_ID +} +``` + +## Étape 4 : Initialiser Terraform + +Initialisez votre projet Terraform pour télécharger le provider : + +```bash +terraform init +``` + +Vous devriez voir : + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Étape 5 : Créer votre première ressource + +### Exemple simple : Machine virtuelle VMware + +Créez un fichier `main.tf` avec une configuration minimale : + +```hcl +# Récupération des ressources existantes nécessaires +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Adaptez avec le nom de votre vCenter +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Adaptez avec le nom de votre datacenter + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Adaptez avec le nom de votre cluster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Adaptez avec le nom de votre datastore cluster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Politique de sauvegarde +} + +# Création d'une machine virtuelle +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Configuration matérielle + memory = 4 * 1024 * 1024 * 1024 # 4 GB en bytes + cpu = 2 + num_cores_per_socket = 1 + + # Options de flexibilité + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Emplacement + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Système d'exploitation + guest_operating_system_moref = "ubuntu64Guest" + + # Politique de sauvegarde + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tags + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output pour afficher l'ID de la VM +output "vm_id" { + description = "ID de la machine virtuelle créée" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference de la VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Adaptation des noms + Les noms des datacenters, clusters et datastores doivent correspondre à ceux disponibles dans votre environnement Cloud Temple. Consultez la console pour identifier les ressources disponibles. +::: + +## Étape 6 : Planifier les changements + +Avant d'appliquer les changements, visualisez ce qui va être créé : + +```bash +terraform plan +``` + +Terraform affiche un plan détaillé : + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Étape 7 : Appliquer la configuration + +Déployez votre infrastructure : + +```bash +terraform apply +``` + +Terraform vous demande confirmation : + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Tapez `yes` et appuyez sur Entrée. + +Terraform crée les ressources : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success Félicitations ! + Vous venez de créer votre première machine virtuelle Cloud Temple avec Terraform ! +::: + +## Étape 8 : Vérifier la création + +### Dans la console Cloud Temple + +1. Connectez-vous à la [Console Cloud Temple](https://shiva.cloud-temple.com) +2. Naviguez vers **IaaS VMWare** > **Machines virtuelles** +3. Vous devriez voir votre Machine Virtuelle `terraform-vm-01` + +### Avec Terraform + +Affichez l'état actuel : + +```bash +terraform show +``` + +Listez les ressources gérées : + +```bash +terraform state list +``` + +Affichez les outputs : + +```bash +terraform output +``` + +## Étape 9 : Modifier votre infrastructure + +Modifiez le fichier `main.tf` pour augmenter la mémoire à 8 GB : + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB au lieu de 4 GB + cpu = 2 + # ... reste de la configuration +} +``` + +Planifiez et appliquez les changements : + +```bash +terraform plan +terraform apply +``` + +Terraform détecte la modification et met à jour la VM : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (autres attributs inchangés) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Étape 10 : Détruire les ressources + +Lorsque vous avez terminé vos tests, supprimez les ressources créées : + +```bash +terraform destroy +``` + +Terraform affiche ce qui va être supprimé et demande confirmation : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Tapez `yes` pour confirmer la suppression. + +## Structure de projet recommandée + +Pour des projets plus complexes, organisez vos fichiers ainsi : + +``` +terraform-cloudtemple/ +├── main.tf # Ressources principales +├── versions.tf # Configuration du provider +├── variables.tf # Déclarations des variables +├── outputs.tf # Déclarations des outputs +├── terraform.tfvars # Valeurs des variables (ne pas versionner) +├── .gitignore # Exclusions Git +└── README.md # Documentation du projet +``` + +### Exemple de .gitignore + +```gitignore +# Fichiers Terraform +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# Fichiers de crash +crash.log +crash.*.log + +# Fichiers de variables sensibles +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Commandes Terraform essentielles + +| Commande | Description | +|----------|-------------| +| `terraform init` | Initialise le répertoire de travail | +| `terraform validate` | Valide la syntaxe de la configuration | +| `terraform fmt` | Formate automatiquement les fichiers | +| `terraform plan` | Affiche le plan d'exécution | +| `terraform apply` | Applique les changements | +| `terraform destroy` | Détruit toutes les ressources | +| `terraform show` | Affiche l'état actuel | +| `terraform output` | Affiche les valeurs des outputs | +| `terraform state list` | Liste les ressources gérées | + +## Bonnes pratiques + +### 1. Utilisez des variables + +```hcl +# variables.tf +variable "environment" { + description = "Environnement de déploiement" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Organisez avec des modules + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Utilisez un backend distant + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Commentez votre code + +```hcl +# Machine virtuelle pour le serveur web de production +# CPU et mémoire dimensionnés pour gérer 1000 req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Configuration matérielle basée sur les benchmarks internes + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Utilisez des datasources + +Ne recréez pas ce qui existe déjà. Utilisez des datasources pour référencer les ressources existantes : + +```hcl +# Référencer un réseau existant +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Dépannage + +### Erreur : "Error: Failed to query available provider packages" + +**Cause** : Problème de connexion au Terraform Registry. + +**Solution** : Vérifiez votre connexion Internet et réessayez `terraform init`. + +### Erreur : "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Cause** : Credentials invalides ou expirés. + +**Solution** : +1. Vérifiez vos variables d'environnement +2. Générez une nouvelle clé API dans la console +3. Vérifiez les permissions de votre Clé API + +### Erreur : "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Cause** : La ressource référencée (datacenter, cluster, etc.) n'existe pas ou vous n'y avez pas accès. + +**Solution** : +1. Vérifiez le nom exact (ou l'uuid) dans la console Cloud Temple +2. Vérifiez vos droits d'accès sur cette ressource + +## Prochaines étapes + +Maintenant que vous maîtrisez les bases, explorez les tutoriels avancés : + +- [Tutoriels IaaS VMware](tutorials.md#iaas-vmware) : Déploiement avancé de VMs, gestion des disques, configuration réseau +- [Tutoriels IaaS OpenSource](tutorials.md#iaas-opensource) : Machines virtuelles XCP-ng, réplication, haute disponibilité +- [Tutoriels Object Storage](tutorials.md#object-storage) : Création de buckets, gestion des ACL, intégration S3 + +## Ressources complémentaires + +- [Terraform Registry - Provider Cloud Temple](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Console Cloud Temple](https://shiva.cloud-temple.com) +- [Concepts Terraform Cloud Temple](concepts.md) diff --git a/docs/terraform/terraform.md b/docs/terraform/terraform.md new file mode 100644 index 00000000..d1b3bd15 --- /dev/null +++ b/docs/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Vue d'ensemble +--- + +Le provider Terraform Cloud Temple vous permet de gérer l'infrastructure de votre compte Cloud Temple en utilisant l'approche Infrastructure as Code (IaC). Il offre une intégration complète avec les services d'infrastructure Cloud Temple, permettant de provisionner, configurer et gérer vos ressources cloud de manière déclarative et reproductible. + +## Fonctionnalités principales + +- **Infrastructure as Code** : Définissez votre infrastructure dans des fichiers de configuration versionnables +- **Gestion déclarative** : Décrivez l'état souhaité de votre infrastructure, Terraform s'occupe du reste +- **Automatisation complète** : Automatisez le provisionnement et la gestion de vos ressources +- **Reproducibilité** : Déployez des environnements identiques de manière fiable +- **Gestion des dépendances** : Terraform gère automatiquement l'ordre de création des ressources + +## Produits couverts + +Le provider Terraform Cloud Temple prend en charge les services suivants : + +### IaaS VMware + +Gérez vos machines virtuelles VMware avec toutes les fonctionnalités avancées de virtualisation : + +- **Machines virtuelles** : Création et configuration de machines virtuelles +- **Disques virtuels** : Création et configuration des disques virtuels +- **Adaptateurs réseau** : Gestion des adapteurs réseau des machines virtuelles +- **Contrôleurs virtuels** : Gestion des contrôleurs de disques et autres périphériques +- **Cloud-Init** : Configuration automatisée au démarrage +- **Sauvegarde** : Intégration avec les politiques de sauvegarde Cloud Temple + +### IaaS OpenSource + +Provisionnez et gérez des machines virtuelles sur l'infrastructure OpenSource basée sur XCP-ng : + +- **Machines virtuelles** : Création et gestion de machines virtuelles +- **Disques virtuels** : Création et configuration des disques virtuels +- **Adaptateurs réseau** : Création et configuration des adapteurs réseau des machines virtuelles +- **Réplication** : Politiques de réplication des données +- **Haute disponibilité** : Configuration HA (disabled, restart, best-effort) +- **Cloud-Init** : Configuration automatisée compatible NoCloud +- **Sauvegarde** : Intégration avec les politiques de sauvegarde Cloud Temple + +### Stockage Objet + +Gérez vos espaces de stockage objet S3-compatible : + +- **Buckets** : Création et configuration de buckets +- **Comptes de stockage** : Gestion des identités et credentials S3 +- **ACL** : Contrôle d'accès granulaire aux buckets +- **Versioning** : Gestion des versions d'objets + +## Conditions préalables + +Avant d'utiliser le provider Terraform Cloud Temple, assurez-vous de disposer de : + +### Accès à la Console Cloud Temple + +Vous devez avoir accès à la [Console Cloud Temple](https://shiva.cloud-temple.com) avec les droits appropriés sur le tenant sur lequel vous souhaitez travailler. + +### Clé API + +Le provider nécessite des identifiants API Cloud Temple : + +- **Client ID** : Identifiant client pour l'authentification +- **Secret ID** : Secret associé au client ID + +Ces credentials peuvent être générés depuis la Console Cloud Temple en suivant [cette procédure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +### Droits et permissions + +Selon les ressources que vous souhaitez gérer, vous devez disposer des rôles appropriés : + +#### Pour IaaS VMware + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` et `backup_iaas_spp_write` (pour la sauvegarde) + +#### Pour IaaS OpenSource + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` et `backup_iaas_opensource_write` (pour la sauvegarde) + +#### Pour Object Storage + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Droits communs + +- `activity_read` +- `tag_read` et `tag_write` + +## Compatibilité Terraform + +Le provider Cloud Temple est compatible avec : + +- **Terraform** : Version 1.0 et supérieures +- **OpenTofu** : Compatible avec les versions récentes + +## Logging et débogage + +Pour activer le logging détaillé du provider : + +```bash +# Logging niveau DEBUG +export TF_LOG=DEBUG +terraform apply + +# Logging au format JSON +export TF_LOG=JSON +terraform apply + +# Enregistrer les logs dans un fichier +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Support et ressources + +- **Documentation officielle** : [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Code source** : [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues** : [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Prochaines étapes + +- [Concepts](concepts.md) : Comprendre les concepts clés du provider +- [Guide de démarrage](quickstart.md) : Créer votre première infrastructure +- [Tutoriels](tutorials.md) : Exemples pratiques et cas d'usage diff --git a/docs/terraform/tutorials.md b/docs/terraform/tutorials.md new file mode 100644 index 00000000..ab12fd17 --- /dev/null +++ b/docs/terraform/tutorials.md @@ -0,0 +1,1303 @@ +--- +title: Tutoriels +--- + +# Tutoriels Terraform Cloud Temple + +Cette page regroupe des tutoriels pratiques pour utiliser le provider Terraform Cloud Temple avec différents services. + +## Sommaire + +- [IaaS VMware](#iaas-vmware) +- [IaaS OpenSource](#iaas-opensource) +- [Stockage Objet](#stockage-objet) + +## IaaS VMware + +### Créer une VM vide + +**Objectif** : Créer une machine virtuelle VMware de base sans système d'exploitation. + +**Prérequis** : +- Accès à un datacenter Cloud Temple +- Credentials API configurés +- Droits nécessaires + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code** : + +```hcl +# Récupération des ressources nécessaires +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Création d'une VM vide +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Configuration matérielle + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-add activé + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Emplacement + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Système d'exploitation guest + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Explications** : +- `guest_operating_system_moref` : Définit le type d'OS pour les pilotes VMware Tools +- La VM est créée sans disque ni réseau (à ajouter séparément) +- Les options hot-add permettent d'ajouter CPU/RAM à chaud + +--- + +### Créer une VM depuis la Marketplace + +**Objectif** : Déployer une VM à partir d'une image de la Marketplace Cloud Temple. + +**Code** : + +```hcl +# Récupération d'un item de la Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Déploiement depuis la Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Source Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Configuration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Explications** : +- `marketplace_item_id` : Référence une image prête à l'emploi +- `datastore_id` : Datastore spécifique requis pour le déploiement Marketplace +- L'image inclut déjà un système d'exploitation configuré + +--- + +### Créer une VM depuis Content Library + +**Objectif** : Déployer une VM à partir d'un template de la Content Library VMware. + +**Code** : + +```hcl +# Récupération de la Content Library +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Récupération d'un item spécifique +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Déploiement depuis Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Source Content Library + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration du disque OS + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # Configuration de l'adaptateur réseau OS + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Explications** : +- Les blocs `os_disk` et `os_network_adapter` configurent les ressources du template +- Ces blocs ne peuvent être utilisés qu'à la création (voir section dédiée) + +--- + +### Configurer Cloud-Init VMware + +**Objectif** : Automatiser la configuration d'une VM au premier démarrage avec Cloud-Init. + +**Prérequis** : Utiliser une image compatible Cloud-Init (ex: Ubuntu Cloud Image en OVF). + +**Fichiers Cloud-Init** : + +Créez `cloud-init/user-data.yml` : + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Créez `cloud-init/network-config.yml` : + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Code Terraform** : + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Configuration Cloud-Init (VMware OVF datasource) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Clés Cloud-Init supportées (VMware)** : +- `user-data` : Configuration principale (base64) +- `network-config` : Configuration réseau (base64) +- `public-keys` : Clés SSH publiques +- `hostname` : Nom d'hôte +- `password` : Mot de passe (ou "RANDOM") +- `instance-id` : Identifiant unique +- `seedfrom` : URL source de configuration + +:::warning Limitation + Cloud-Init n'est exécuté qu'au premier démarrage de la VM. +::: +--- + +### Créer un disque virtuel et l'attacher à une VM + +**Objectif** : Ajouter du stockage supplémentaire à une machine virtuelle existante. + +**Code** : + +```hcl +# Référence à une VM existante +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Création d'un disque virtuel +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # Attachement à la VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Taille du disque + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Mode du disque + disk_mode = "persistent" + + # Type de provisionnement + provisioning_type = "dynamic" +} +``` + +**Modes de disque disponibles** : +- `persistent` : Les modifications sont immédiatement et définitivement enregistrées sur le disque virtuel. +- `independent_nonpersistent` : Les modifications apportées au disque virtuel sont enregistrées dans un journal de reprise et supprimées à la mise hors tension. +- `independent_persistent` : Les modifications sont immédiatement et définitivement enregistrées sur le disque virtuel. Non affecté par les snapshots. + +**Types de provisionnement** : +- `dynamic` : Économise de l'espace de stockage en allouant de l'espace de manière dynamique selon les besoins. La création est rapide. +- `staticImmediate` : Alloue tout l'espace disque lors de la création, mais les blocs sont remis à zéro lors de la première écriture. +- `staticDiffered` : Alloue et remet à zéro tout l'espace disque lors de la création. + +--- + +### Créer une interface réseau et l'attacher à une VM + +**Objectif** : Ajouter une carte réseau à une machine virtuelle. + +**Code** : + +```hcl +# Récupération du réseau +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# Référence à la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Création d'un adaptateur réseau +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # VM cible + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Réseau + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Type d'adaptateur + type = "VMXNET3" + + # Connexion automatique au démarrage + connect_on_power_on = true + + # MAC address (optionnel, générée automatiquement si omis) + # mac_address = "00:50:56:xx:xx:xx" +} +``` +:::info Type d'adaptateur réseaux supportés + Les types d'adaptateurs compatible pouvant être utilisés dépendent de l'OS utilisé sur la Machine Virtuelle ainsi que de la version de VMWare. +::: + +--- + +### Créer un contrôleur virtuel et l'attacher à une VM + +**Objectif** : Ajouter un contrôleur de disque à une machine virtuelle. + +**Code** : + +```hcl +# Référence à la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Création d'un contrôleur SCSI +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # VM cible + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Type de contrôleur + type = "SCSI" +} +``` + +**Types de contrôleurs** : +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## IaaS OpenSource + +### Créer une VM depuis un template + +**Objectif** : Déployer une machine virtuelle à partir d'un template du catalogue. + +**Prérequis** : +- Accès à l'infrastructure OpenSource Cloud Temple +- Droits nécessaires : + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code** : + +```hcl +# Récupération d'un template +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Récupération de l'hôte +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Récupération du storage repository +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Récupération du réseau +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Récupération de la politique de backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# Création de la VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Source + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Configuration matérielle + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Options + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # Disque OS (doit correspondre au template) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # Adaptateur réseau OS + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Backup + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Ordre de boot + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Explications** : +- `high_availability` : Options disponibles: `disabled`, `restart`, `best-effort` (Voir [documentation](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) sur la Haute Disponibilité) +- `boot_firmware` : `bios` ou `uefi` +- `secure_boot` : Uniquement avec UEFI + +--- + +### Créer une VM depuis la Marketplace + +**Objectif** : Déployer une VM depuis la Marketplace Cloud Temple sur le IaaS OpenSource. + +**Code** : + +```hcl +# Récupération d'un item Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Déploiement depuis Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Source Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Configurer la Réplication + +**Objectif** : Mettre en place une politique de réplication pour une VM. + +**Code** : + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Création d'une politique de réplication +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Association à une VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... configuration standard ... + + # Association de la politique de réplication + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Explications** : +- `interval` : Intervalle de réplication. Peut être formulé en `minutes`ou `hours` +- `storage_repository_id` : Storage Repository vers lequel les disques de la VM vont être répliqué. Doit être sur une AZ différente de la VM d'origine + +--- + +### Configurer la Sauvegarde + +**Objectif** : Appliquer une politique de sauvegarde à une VM. + +**Code** : + +```hcl +# Récupération des politiques de backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM avec plusieurs politiques de backup +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... configuration standard ... + + # Plusieurs politiques peuvent être appliquées + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Backup obligatoire + Dans un environnement SecNumCloud, au moins une politique de backup doit être définie pour pouvoir démarrer la VM. +::: +--- + +### Configurer la Haute Disponibilité + +**Objectif** : Configurer le comportement HA d'une machine virtuelle. + +**Code** : + +```hcl +# VM avec HA désactivée +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM avec restart prioritaire +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM avec best-effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Modes HA disponibles** : + +Voir documentation sur la [Haute Disponibilité](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) dans l'infrastructure OpenSource + +| Mode | Description | Usage | +|------|-------------|-------| +| `disabled` | Pas de HA | Environnements de développement | +| `restart` | Redémarrage haute priorité | Production critique | +| `best-effort` | Redémarrage si ressources disponibles | Production standard | + +--- + +### Configurer Cloud-Init OpenSource + +**Objectif** : Automatiser la configuration avec Cloud-Init (NoCloud datasource). + +**Prérequis** : Image compatible Cloud-Init NoCloud. + +**Fichiers Cloud-Init** : + +Créez `cloud-init/cloud-config.yml` : + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Créez `cloud-init/network-config.yml` : + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important A noter + Adaptez la configuration cloud-init à vos besoin et à la version de Cloud-Init installée sur votre machine. Le format et la syntaxe peuvent évoluer en fonction des versions. +::: + +**Code Terraform** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Configuration Cloud-Init (NoCloud datasource) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Différence avec VMware** : +- OpenSource utilise la datasource **NoCloud** +- Clés supportées : `cloud_config` et `network_config` +- Pas de `filebase64()`, utiliser `file()` directement + +--- + + +### Comprendre os_disk et os_network_adapter + +Les blocs `os_disk` et `os_network_adapter` sont des blocs spéciaux utilisables **uniquement lors de la création** d'une machine virtuelle à partir de : + +- Content Library +- Template +- Marketplace Cloud Temple +- Clone d'une VM existante + +:::info info + Ils servent à réferencer les disques virtuels et adaptateurs réseaux déployé par le template afin de pouvoir en modifier les paramètres par la suite sans avoir à les importer manuellement. Ils ne créent en aucun cas une nouvelle ressource. +::: + +**Caractéristiques importantes** : + +1. **Création uniquement** : Ces blocs ne peuvent être définis que lors du `terraform apply` initial +3. **Alternative** : Utilisez la commande `terraform import` pour les importer manuellement + +--- + +### Utiliser os_disk + +**IaaS VMware** : + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration du disque OS existant dans le template + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Redimensionner à 100 GB + disk_mode = "persistent" + } +} +``` + +**IaaS OpenSource** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # Configuration du disque OS + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... autres configurations +} +``` + +--- + +### Utiliser os_network_adapter + +**IaaS VMware** : + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration de l'adaptateur réseau du template + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Optionnel + } +} +``` + +**IaaS OpenSource** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Configuration de l'adaptateur réseau + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Optionnel + tx_checksumming = true + attached = true + } + + # ... autres configurations +} +``` + +:::info A noter + Vous pouvez tout à fait combiner les deux approches en réferençant les disques et/ou adaptateurs réseaux d'une VM et en ajouter d'autres via les ressource `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` et `cloudtemple_compute_iaas_vmware/opensource_network_adapter` +::: + +--- + +**Bonnes pratiques** : +1. Utilisez `os_disk` et `os_network_adapter` pour la configuration initiale du template +2. Utilisez les ressources dédiées pour ajouter des ressources supplémentaires + +--- + +## Stockage Objet + +### Créer un bucket + +**Objectif** : Créer un bucket de stockage objet S3-compatible. + +**Prérequis** : Droits `object-storage_write` + +**Code** : + +```hcl +# Bucket privé +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Bucket public +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket avec accès personnalisé (whitelist IP) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # Liste blanche d'adresses IP/CIDR + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket avec versioning activé +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Outputs utiles +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Types d'accès** : +- `private` : Accès restreint aux adresses IP du tenant +- `public` : Accès public en lecture +- `custom` : Accès limité aux IPs de la whitelist + +**Versioning** : +- `Enabled` : Active le versioning des objets +- `Suspended` : Suspend le versioning (conserve les versions existantes) + +--- + +### Créer un compte de stockage + +**Objectif** : Créer un compte de stockage avec des credentials S3. + +**Code** : + +```hcl +# Création d'un compte de stockage +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Outputs pour utiliser les credentials +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Informations sensibles + Les credentials sont affichés une seule fois. Stockez-les de manière sécurisée (ex: HashiCorp Vault, AWS Secrets Manager). +::: +--- + +### Créer des ACL via ressource dédiée + +**Objectif** : Gérer les permissions d'accès aux buckets avec des ACL. + +**Code** : + +```hcl +# Récupération des rôles disponibles +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Récupération de comptes de stockage existants +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL pour l'équipe dev (lecture seule) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL pour l'équipe ops (maintainer) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Rôles disponibles** : +- `read_write` : Lecture et écriture +- `write_only`: Écriture seule +- `read_only` : Lecture seule +- `maintainer` : Accès total + +--- + +### Configurer des ACL directement dans le bucket + +**Objectif** : Définir les ACL lors de la création du bucket. + +**Code** : + +```hcl +# Récupération des ressources +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket avec ACL intégrées +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # Définition des ACL dans le bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Différence avec les ressources ACL dédiées** : +- **Inline** : ACL définies directement dans le bucket (plus simple pour des configurations statiques) +- **Ressource dédiée** : ACL gérées séparément (plus flexible, permet des modifications indépendantes) + +--- + +### Utiliser les datasources + +**Objectif** : Interroger les métadonnées des buckets et lister les fichiers. + +**Code** : + +```hcl +# Datasource pour lister les fichiers d'un bucket +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Afficher tous les fichiers +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Filtrer un fichier spécifique +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Récupération d'un compte de stockage existant +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### Intégration S3 avec le provider AWS + +**Objectif** : Utiliser le provider AWS pour uploader des fichiers vers le stockage objet Cloud Temple. + +**Code** : + +```hcl +# Création du compte et du bucket +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# Configuration du provider AWS pour Cloud Temple S3 +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Utilisation des credentials Cloud Temple + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Endpoint Cloud Temple + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Configuration pour éviter la validation AWS + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Upload d'un fichier +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Upload de plusieurs fichiers +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Vérification des fichiers uploadés +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Conclusion + +Cette documentation couvre les principaux cas d'usage du provider Terraform Cloud Temple. Pour aller plus loin : + +- Consultez la [documentation officielle du provider](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Explorez les [exemples sur GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Utilisez la [Console Cloud Temple](https://shiva.cloud-temple.com) pour identifier les ressources disponibles + +:::info Besoin d'aide ? + Pour toute question ou problème, consultez la [section Issues sur GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) ou contactez le support Cloud Temple. +::: diff --git a/i18n/de/docusaurus-plugin-content-docs/current/terraform/concepts.md b/i18n/de/docusaurus-plugin-content-docs/current/terraform/concepts.md new file mode 100644 index 00000000..38d2fff6 --- /dev/null +++ b/i18n/de/docusaurus-plugin-content-docs/current/terraform/concepts.md @@ -0,0 +1,473 @@ +--- +title: Konzepte +--- + +# Terraform-Konzepte im Cloud Temple Provider + +Diese Seite präsentiert die grundlegenden Konzepte, die notwendig sind, um den Cloud Temple Terraform Provider effektiv zu verstehen und zu nutzen. + +## Infrastructure as Code (IaC) + +Infrastructure as Code ist ein Ansatz, bei dem IT-Infrastruktur durch menschenlesbare Konfigurationsdateien verwaltet und bereitgestellt wird, anstatt durch manuelle Konfiguration oder interaktive Tools. + +### Vorteile von IaC mit Terraform + +- **Versionierung**: Infrastruktur wird in Dateien definiert, die versioniert werden können (Git) +- **Zusammenarbeit**: Teams können gemeinsam an derselben Infrastruktur arbeiten +- **Automatisierung**: Reduzierung menschlicher Fehler und Zeitersparnis +- **Dokumentation**: Der Code beschreibt die Infrastruktur explizit +- **Reproduzierbarkeit**: Bereitstellung identischer Umgebungen in Minuten + +## Terraform Provider + +Ein Terraform Provider ist ein Plugin, das Terraform die Interaktion mit einer spezifischen API ermöglicht. Der Cloud Temple Provider fungiert als Abstraktionsschicht zwischen Ihren Terraform-Konfigurationsdateien und den Cloud Temple APIs. + +### Provider-Deklaration + +Der Provider muss in einem `terraform`-Block mit `required_providers` deklariert werden: + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Authentifizierung + +Der Provider authentifiziert sich bei den Cloud Temple APIs mit: + +1. **Client ID**: Eindeutiger Identifikator für Ihre Anwendung +2. **Secret ID**: Geheimer Schlüssel, der mit der Client ID verknüpft ist + +Diese Anmeldeinformationen werden über die Cloud Temple Konsole generiert und ermöglichen es dem Provider, Operationen in Ihrem Namen auszuführen. + +:::info Best Practices + Speichern Sie Ihre Anmeldeinformationen in Umgebungsvariablen oder einem Secrets-Manager, niemals direkt im Code. +::: + +## Ressourcen + +Eine Ressource repräsentiert eine Infrastrukturkomponente, die erstellt, gelesen, aktualisiert oder gelöscht werden kann (CRUD-Operationen). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Cloud Temple Ressourcentypen + +#### VMware IaaS + +- `cloudtemple_compute_virtual_machine`: Virtuelle Maschine +- `cloudtemple_compute_virtual_disk`: Virtuelle Festplatte +- `cloudtemple_compute_network_adapter`: Netzwerkschnittstelle +- `cloudtemple_compute_virtual_controller`: Gerätecontroller + +#### OpenSource IaaS + +- `cloudtemple_compute_iaas_opensource_virtual_machine`: Virtuelle Maschine +- `cloudtemple_compute_iaas_opensource_virtual_disk`: Festplatte +- `cloudtemple_compute_iaas_opensource_network_adapter`: Netzwerkschnittstelle +- `cloudtemple_compute_iaas_opensource_replication_policy`: Replikationsrichtlinie + +#### Object Storage + +- `cloudtemple_object_storage_bucket`: S3-Bucket +- `cloudtemple_object_storage_storage_account`: Speicherkonto +- `cloudtemple_object_storage_acl_entry`: Bucket-ACL +- `cloudtemple_object_storage_global_access_key`: Globaler Zugriffsschlüssel für Namespace + +### Attribute und Argumente + +Jede Ressource hat: + +- **Argumente**: Werte, die Sie konfigurieren (Eingaben) +- **Attribute**: Werte, die von der Ressource zurückgegeben werden (Ausgaben) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Argumente (Konfiguration) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Attribute (automatisch berechnet) + # id, moref, machine_manager_id, etc. +} + +# Verweis auf ein Attribut +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Datasources ermöglichen es Ihnen, Informationen über bestehende Ressourcen abzurufen, ohne sie zu verwalten. Sie sind **nur lesbar**. + +### Verwendung von Datasources + +```hcl +# Abrufen eines bestehenden Datacenters +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Abrufen eines Clusters +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Verwendung in einer Ressource +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Hauptdatasources + +Die vollständige Liste der verfügbaren Datasources im Cloud Temple Terraform Provider finden Sie in der [Terraform-Dokumentation](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Compute-Infrastruktur + +| Datasource | Beschreibung | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Virtuelles Datacenter | +| `cloudtemple_compute_host_cluster` | Host-Cluster | +| `cloudtemple_compute_datastore_cluster` | Datastore-Cluster | +| `cloudtemple_compute_datastore` | Einzelner Datastore | +| `cloudtemple_compute_network` | Netzwerk (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates und Marketplace + +| Datasource | Beschreibung | +|------------|-------------| +| `cloudtemple_compute_content_library` | Inhaltsbibliothek | +| `cloudtemple_compute_content_library_item` | Bibliothekselement | +| `cloudtemple_marketplace_item` | Cloud Temple Marketplace-Element | +| `cloudtemple_compute_iaas_opensource_template` | Template im OpenSource IaaS-Katalog | + +#### Backup + +| Datasource | Beschreibung | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | VMware Backup-SLA-Richtlinie | +| `cloudtemple_backup_iaas_opensource_policy` | OpenSource Backup-Richtlinie | + +#### Object Storage + +| Datasource | Beschreibung | +|------------|-------------| +| `cloudtemple_object_storage_role` | Verfügbare Rollen für ACLs | +| `cloudtemple_object_storage_bucket_files` | Dateien in einem Bucket | +| `cloudtemple_object_storage_storage_account` | Bestehendes Speicherkonto | + +## Terraform State + +Der Terraform State ist eine Datei, die die Zuordnung zwischen Ihrer Konfiguration und den tatsächlichen Ressourcen in der Cloud aufrechterhält. + +### terraform.tfstate Datei + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Remote Backend + +Für die Teamzusammenarbeit speichern Sie den State in einem Remote-Backend: + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + Die `terraform.tfstate`-Datei enthält sensible Informationen. Committen Sie sie niemals in Git und verwenden Sie ein sicheres Backend für die Speicherung. +::: + +:::info + OpenTofu bietet standardmäßig State-Verschlüsselung ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: + +## Terraform-Lebenszyklus + +### 1. Initialisierung (terraform init) + +Initialisieren Sie das Arbeitsverzeichnis und laden Sie den Cloud Temple Provider herunter: + +```bash +terraform init +``` + +Dieser Befehl: +- Lädt den Provider aus dem Terraform Registry herunter +- Initialisiert das Backend (falls konfiguriert) +- Erstellt das `.terraform/`-Verzeichnis + +### 2. Planung (terraform plan) + +Erzeugen Sie einen Ausführungsplan, der die anzuwendenden Änderungen zeigt: + +```bash +terraform plan +``` + +Der Plan zeigt: +- **Zu erstellende Ressourcen** (`+`) +- **Zu ändernde Ressourcen** (`~`) +- **Zu löschende Ressourcen** (`-`) +- **Neu zu erstellende Ressourcen** (`-/+`) + +### 3. Anwendung (terraform apply) + +Wenden Sie Änderungen an, um den gewünschten Zustand zu erreichen: + +```bash +terraform apply +``` + +Terraform: +1. Erzeugt einen Plan +2. Fragt nach Bestätigung (außer mit `--auto-approve`) +3. Wendet Änderungen an +4. Aktualisiert den State + +### 4. Zerstörung (terraform destroy) + +Zerstören Sie alle verwalteten Ressourcen: + +```bash +terraform destroy +``` + +:::danger Achtung + Dieser Befehl löscht alle Ressourcen dauerhaft. Mit Vorsicht verwenden. +::: + +### 5. Weitere nützliche Befehle + +```bash +# Aktuellen State anzeigen +terraform show + +# Ressourcen auflisten +terraform state list + +# Konfiguration validieren +terraform validate + +# Dateien formatieren +terraform fmt + +# Outputs anzeigen +terraform output +``` + +## Abhängigkeiten und Ausführungsreihenfolge + +Terraform analysiert automatisch Abhängigkeiten zwischen Ressourcen. + +### Implizite Abhängigkeiten + +Terraform erkennt Referenzen zwischen Ressourcen: + +```hcl +# Die Datasource wird zuerst ausgewertet +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Dann wird die VM erstellt (implizite Abhängigkeit über datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Schließlich wird die Festplatte angehängt (Abhängigkeit über virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Explizite Abhängigkeiten + +Um eine bestimmte Reihenfolge zu erzwingen, verwenden Sie `depends_on`: + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variablen und Outputs + +### Eingabevariablen + +Machen Sie Ihre Konfiguration wiederverwendbar: + +```hcl +variable "vm_name" { + description = "Name der virtuellen Maschine" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Speicher in GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Outputs + +Geben Sie Informationen nach der Anwendung preis: + +```hcl +output "vm_id" { + description = "ID der virtuellen Maschine" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "VMware Managed Object Reference" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Module + +Module ermöglichen es Ihnen, Konfigurationen zu gruppieren und wiederzuverwenden: + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Best Practices + +### Dateiorganisation + +``` +. +├── main.tf # Hauptressourcen +├── variables.tf # Variablendeklarationen +├── outputs.tf # Output-Deklarationen +├── versions.tf # Terraform- und Provider-Versionen +├── terraform.tfvars # Variablenwerte (nicht committen) +└── modules/ # Wiederverwendbare Module + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Secrets-Verwaltung + +```hcl +# ❌ Zu vermeiden +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "klartext-secret" +} + +# ✅ Empfohlen +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Verwendung von Tags + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Nächste Schritte + +- [Erste Schritte](quickstart.md): Erstellen Sie Ihre erste Infrastruktur mit Terraform +- [Tutorials](tutorials.md): Praktische Beispiele für jeden Service diff --git a/i18n/de/docusaurus-plugin-content-docs/current/terraform/quickstart.md b/i18n/de/docusaurus-plugin-content-docs/current/terraform/quickstart.md new file mode 100644 index 00000000..95cfe5b5 --- /dev/null +++ b/i18n/de/docusaurus-plugin-content-docs/current/terraform/quickstart.md @@ -0,0 +1,566 @@ +--- +title: Erste Schritte +--- + +# Schnellstartanleitung + +Diese Anleitung führt Sie Schritt für Schritt durch die Bereitstellung Ihrer ersten Cloud Temple-Infrastruktur mit Terraform. + +## Voraussetzungen + +Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen: + +- Ein aktives Cloud Temple-Konto +- Zugriff auf die [Cloud Temple Console](https://shiva.cloud-temple.com) +- API-Schlüssel (Client ID und Secret ID) +- Terraform auf Ihrem Computer installiert (Version 1.0 oder höher) + +## Schritt 1: Terraform installieren + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Laden Sie die ausführbare Datei von [terraform.io](https://www.terraform.io/downloads) herunter oder verwenden Sie Chocolatey: + +```powershell +choco install terraform +``` + +### Überprüfung der Installation + +```bash +terraform version +``` + +Sie sollten eine ähnliche Ausgabe sehen: + +``` +Terraform v1.6.0 +``` + +## Schritt 2: Ihren API-Schlüssel erhalten + +### Generieren eines API-Schlüssels in der Console + +Diese Zugangsdaten können über die Cloud Temple Console generiert werden, indem Sie [dieser Anleitung](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api) folgen. + +:::warning Sicherheit + Bewahren Sie diese Zugangsdaten sicher auf. Die Secret ID wird nur einmal angezeigt. +::: + +### Konfigurieren von Umgebungsvariablen + +Exportieren Sie Ihre Zugangsdaten als Umgebungsvariablen: + +**Linux/macOS:** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell):** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Schritt 3: Ihr Terraform-Projekt erstellen + +### Projektverzeichnis erstellen + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Provider-Konfigurationsdatei erstellen + +Erstellen Sie eine Datei `versions.tf`: + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Zugangsdaten werden automatisch aus Umgebungsvariablen abgerufen + # CLOUDTEMPLE_CLIENT_ID und CLOUDTEMPLE_SECRET_ID +} +``` + +## Schritt 4: Terraform initialisieren + +Initialisieren Sie Ihr Terraform-Projekt, um den Provider herunterzuladen: + +```bash +terraform init +``` + +Sie sollten sehen: + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Schritt 5: Ihre erste Ressource erstellen + +### Einfaches Beispiel: VMware virtuelle Maschine + +Erstellen Sie eine Datei `main.tf` mit einer minimalen Konfiguration: + +```hcl +# Abrufen notwendiger vorhandener Ressourcen +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Passen Sie den Namen Ihres vCenters an +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Passen Sie den Namen Ihres Rechenzentrums an + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Passen Sie den Namen Ihres Clusters an + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Passen Sie den Namen Ihres Datastore-Clusters an + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Backup-Richtlinie +} + +# Erstellen einer virtuellen Maschine +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Hardware-Konfiguration + memory = 4 * 1024 * 1024 * 1024 # 4 GB in Bytes + cpu = 2 + num_cores_per_socket = 1 + + # Flexibilitätsoptionen + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Standort + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Betriebssystem + guest_operating_system_moref = "ubuntu64Guest" + + # Backup-Richtlinie + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tags + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output zur Anzeige der VM-ID +output "vm_id" { + description = "ID der erstellten virtuellen Maschine" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference der VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Namen anpassen + Die Namen der Rechenzentren, Cluster und Datastores müssen mit denen in Ihrer Cloud Temple-Umgebung übereinstimmen. Überprüfen Sie die Console, um verfügbare Ressourcen zu identifizieren. +::: + +## Schritt 6: Änderungen planen + +Bevor Sie die Änderungen anwenden, visualisieren Sie, was erstellt wird: + +```bash +terraform plan +``` + +Terraform zeigt einen detaillierten Plan an: + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Schritt 7: Konfiguration anwenden + +Stellen Sie Ihre Infrastruktur bereit: + +```bash +terraform apply +``` + +Terraform fragt nach Bestätigung: + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Geben Sie `yes` ein und drücken Sie Enter. + +Terraform erstellt die Ressourcen: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success Glückwunsch! + Sie haben gerade Ihre erste Cloud Temple virtuelle Maschine mit Terraform erstellt! +::: + +## Schritt 8: Erstellung überprüfen + +### In der Cloud Temple Console + +1. Melden Sie sich bei der [Cloud Temple Console](https://shiva.cloud-temple.com) an +2. Navigieren Sie zu **IaaS VMWare** > **Virtuelle Maschinen** +3. Sie sollten Ihre virtuelle Maschine `terraform-vm-01` sehen + +### Mit Terraform + +Aktuellen Zustand anzeigen: + +```bash +terraform show +``` + +Verwaltete Ressourcen auflisten: + +```bash +terraform state list +``` + +Outputs anzeigen: + +```bash +terraform output +``` + +## Schritt 9: Ihre Infrastruktur ändern + +Ändern Sie die Datei `main.tf`, um den Speicher auf 8 GB zu erhöhen: + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB statt 4 GB + cpu = 2 + # ... Rest der Konfiguration +} +``` + +Planen und wenden Sie die Änderungen an: + +```bash +terraform plan +terraform apply +``` + +Terraform erkennt die Änderung und aktualisiert die VM: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (andere Attribute unverändert) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Schritt 10: Ressourcen zerstören + +Wenn Sie mit dem Testen fertig sind, löschen Sie die erstellten Ressourcen: + +```bash +terraform destroy +``` + +Terraform zeigt an, was gelöscht wird, und fragt nach Bestätigung: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Geben Sie `yes` ein, um die Löschung zu bestätigen. + +## Empfohlene Projektstruktur + +Für komplexere Projekte organisieren Sie Ihre Dateien wie folgt: + +``` +terraform-cloudtemple/ +├── main.tf # Hauptressourcen +├── versions.tf # Provider-Konfiguration +├── variables.tf # Variablendeklarationen +├── outputs.tf # Output-Deklarationen +├── terraform.tfvars # Variablenwerte (nicht versionieren) +├── .gitignore # Git-Ausschlüsse +└── README.md # Projektdokumentation +``` + +### Beispiel .gitignore + +```gitignore +# Terraform-Dateien +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# Crash-Dateien +crash.log +crash.*.log + +# Sensible Variablendateien +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Wichtige Terraform-Befehle + +| Befehl | Beschreibung | +|--------|--------------| +| `terraform init` | Arbeitsverzeichnis initialisieren | +| `terraform validate` | Konfigurationssyntax validieren | +| `terraform fmt` | Dateien automatisch formatieren | +| `terraform plan` | Ausführungsplan anzeigen | +| `terraform apply` | Änderungen anwenden | +| `terraform destroy` | Alle Ressourcen zerstören | +| `terraform show` | Aktuellen Zustand anzeigen | +| `terraform output` | Output-Werte anzeigen | +| `terraform state list` | Verwaltete Ressourcen auflisten | + +## Best Practices + +### 1. Variablen verwenden + +```hcl +# variables.tf +variable "environment" { + description = "Bereitstellungsumgebung" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Mit Modulen organisieren + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Remote Backend verwenden + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Code kommentieren + +```hcl +# Virtuelle Maschine für Produktions-Webserver +# CPU und Speicher dimensioniert für 1000 Req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Hardware-Konfiguration basierend auf internen Benchmarks + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Datasources verwenden + +Erstellen Sie nicht neu, was bereits existiert. Verwenden Sie Datasources, um auf vorhandene Ressourcen zu verweisen: + +```hcl +# Vorhandenes Netzwerk referenzieren +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Fehlerbehebung + +### Fehler: "Error: Failed to query available provider packages" + +**Ursache**: Verbindungsproblem zum Terraform Registry. + +**Lösung**: Überprüfen Sie Ihre Internetverbindung und versuchen Sie `terraform init` erneut. + +### Fehler: "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Ursache**: Ungültige oder abgelaufene Zugangsdaten. + +**Lösung**: +1. Überprüfen Sie Ihre Umgebungsvariablen +2. Generieren Sie einen neuen API-Schlüssel in der Console +3. Überprüfen Sie die Berechtigungen Ihres API-Schlüssels + +### Fehler: "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Ursache**: Die referenzierte Ressource (Rechenzentrum, Cluster usw.) existiert nicht oder Sie haben keinen Zugriff darauf. + +**Lösung**: +1. Überprüfen Sie den genauen Namen (oder uuid) in der Cloud Temple Console +2. Überprüfen Sie Ihre Zugriffsrechte auf diese Ressource + +## Nächste Schritte + +Nachdem Sie die Grundlagen beherrschen, erkunden Sie erweiterte Tutorials: + +- [VMware IaaS Tutorials](tutorials.md#iaas-vmware): Erweiterte VM-Bereitstellung, Disk-Verwaltung, Netzwerkkonfiguration +- [OpenSource IaaS Tutorials](tutorials.md#iaas-opensource): XCP-ng virtuelle Maschinen, Replikation, Hochverfügbarkeit +- [Object Storage Tutorials](tutorials.md#object-storage): Bucket-Erstellung, ACL-Verwaltung, S3-Integration + +## Zusätzliche Ressourcen + +- [Terraform Registry - Cloud Temple Provider](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Cloud Temple Console](https://shiva.cloud-temple.com) +- [Cloud Temple Terraform Konzepte](concepts.md) diff --git a/i18n/de/docusaurus-plugin-content-docs/current/terraform/terraform.md b/i18n/de/docusaurus-plugin-content-docs/current/terraform/terraform.md new file mode 100644 index 00000000..c81a5822 --- /dev/null +++ b/i18n/de/docusaurus-plugin-content-docs/current/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Übersicht +--- + +Der Cloud Temple Terraform Provider ermöglicht es Ihnen, Ihre Cloud Temple Konto-Infrastruktur mit dem Infrastructure as Code (IaC) Ansatz zu verwalten. Er bietet eine vollständige Integration mit den Cloud Temple Infrastrukturdiensten und ermöglicht es Ihnen, Ihre Cloud-Ressourcen deklarativ und reproduzierbar bereitzustellen, zu konfigurieren und zu verwalten. + +## Hauptfunktionen + +- **Infrastructure as Code**: Definieren Sie Ihre Infrastruktur in versionierbaren Konfigurationsdateien +- **Deklaratives Management**: Beschreiben Sie den gewünschten Zustand Ihrer Infrastruktur, Terraform kümmert sich um den Rest +- **Vollständige Automatisierung**: Automatisieren Sie die Bereitstellung und Verwaltung Ihrer Ressourcen +- **Reproduzierbarkeit**: Stellen Sie identische Umgebungen zuverlässig bereit +- **Abhängigkeitsverwaltung**: Terraform verwaltet automatisch die Reihenfolge der Ressourcenerstellung + +## Abgedeckte Produkte + +Der Cloud Temple Terraform Provider unterstützt die folgenden Dienste: + +### VMware IaaS + +Verwalten Sie Ihre VMware virtuellen Maschinen mit allen erweiterten Virtualisierungsfunktionen: + +- **Virtuelle Maschinen**: Erstellung und Konfiguration virtueller Maschinen +- **Virtuelle Festplatten**: Erstellung und Konfiguration virtueller Festplatten +- **Netzwerkadapter**: Verwaltung der Netzwerkadapter virtueller Maschinen +- **Virtuelle Controller**: Verwaltung von Festplattencontrollern und anderen Geräten +- **Cloud-Init**: Automatisierte Startkonfiguration +- **Backup**: Integration mit Cloud Temple Backup-Richtlinien + +### OpenSource IaaS + +Bereitstellung und Verwaltung virtueller Maschinen auf OpenSource-Infrastruktur basierend auf XCP-ng: + +- **Virtuelle Maschinen**: Erstellung und Verwaltung virtueller Maschinen +- **Virtuelle Festplatten**: Erstellung und Konfiguration virtueller Festplatten +- **Netzwerkadapter**: Erstellung und Konfiguration der Netzwerkadapter virtueller Maschinen +- **Replikation**: Datenreplikationsrichtlinien +- **Hochverfügbarkeit**: HA-Konfiguration (disabled, restart, best-effort) +- **Cloud-Init**: NoCloud-kompatible automatisierte Konfiguration +- **Backup**: Integration mit Cloud Temple Backup-Richtlinien + +### Objektspeicher + +Verwalten Sie Ihre S3-kompatiblen Objektspeicherplätze: + +- **Buckets**: Bucket-Erstellung und -Konfiguration +- **Speicherkonten**: S3-Identitäts- und Credential-Verwaltung +- **ACL**: Granulare Bucket-Zugriffskontrolle +- **Versionierung**: Objektversionsverwaltung + +## Voraussetzungen + +Bevor Sie den Cloud Temple Terraform Provider verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen: + +### Zugriff auf die Cloud Temple Konsole + +Sie müssen Zugriff auf die [Cloud Temple Konsole](https://shiva.cloud-temple.com) mit entsprechenden Rechten auf dem Tenant haben, an dem Sie arbeiten möchten. + +### API-Schlüssel + +Der Provider benötigt Cloud Temple API-Anmeldeinformationen: + +- **Client ID**: Client-Identifikator für die Authentifizierung +- **Secret ID**: Mit der Client-ID verknüpftes Geheimnis + +Diese Anmeldeinformationen können über die Cloud Temple Konsole generiert werden, indem Sie [dieser Prozedur](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api) folgen. + +### Rechte und Berechtigungen + +Abhängig von den Ressourcen, die Sie verwalten möchten, müssen Sie über die entsprechenden Rollen verfügen: + +#### Für VMware IaaS + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` und `backup_iaas_spp_write` (für Backup) + +#### Für OpenSource IaaS + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` und `backup_iaas_opensource_write` (für Backup) + +#### Für Objektspeicher + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Gemeinsame Rechte + +- `activity_read` +- `tag_read` und `tag_write` + +## Terraform-Kompatibilität + +Der Cloud Temple Provider ist kompatibel mit: + +- **Terraform**: Version 1.0 und höher +- **OpenTofu**: Kompatibel mit aktuellen Versionen + +## Protokollierung und Debugging + +Um detaillierte Provider-Protokollierung zu aktivieren: + +```bash +# DEBUG-Level-Protokollierung +export TF_LOG=DEBUG +terraform apply + +# JSON-Format-Protokollierung +export TF_LOG=JSON +terraform apply + +# Protokolle in eine Datei speichern +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Support und Ressourcen + +- **Offizielle Dokumentation**: [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Quellcode**: [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues**: [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Nächste Schritte + +- [Konzepte](concepts.md): Verstehen Sie die wichtigsten Provider-Konzepte +- [Erste Schritte](quickstart.md): Erstellen Sie Ihre erste Infrastruktur +- [Tutorials](tutorials.md): Praktische Beispiele und Anwendungsfälle diff --git a/i18n/de/docusaurus-plugin-content-docs/current/terraform/tutorials.md b/i18n/de/docusaurus-plugin-content-docs/current/terraform/tutorials.md new file mode 100644 index 00000000..66831cdd --- /dev/null +++ b/i18n/de/docusaurus-plugin-content-docs/current/terraform/tutorials.md @@ -0,0 +1,1306 @@ +--- +title: Tutorials +--- + +# Cloud Temple Terraform Tutorials + +Diese Seite enthält praktische Tutorials zur Verwendung des Cloud Temple Terraform Providers mit verschiedenen Diensten. + +## Inhaltsverzeichnis + +- [VMware IaaS](#vmware-iaas) +- [OpenSource IaaS](#opensource-iaas) +- [Objektspeicher](#objektspeicher) + +## VMware IaaS + +### Eine leere VM erstellen + +**Ziel**: Erstellen Sie eine einfache VMware-Virtual Machine ohne Betriebssystem. + +**Voraussetzungen**: +- Zugriff auf ein Cloud Temple Rechenzentrum +- Konfigurierte API-Anmeldeinformationen +- Erforderliche Berechtigungen: + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code**: + +```hcl +# Erforderliche Ressourcen abrufen +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Leere VM erstellen +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Hardware-Konfiguration + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-Add aktiviert + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Standort + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Gast-Betriebssystem + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Erklärungen**: +- `guest_operating_system_moref`: Definiert den OS-Typ für VMware Tools-Treiber +- Die VM wird ohne Festplatte oder Netzwerk erstellt (separat hinzuzufügen) +- Hot-Add-Optionen ermöglichen das Hinzufügen von CPU/RAM im laufenden Betrieb + +--- + +### Eine VM aus dem Marketplace erstellen + +**Ziel**: Bereitstellen einer VM aus einem Cloud Temple Marketplace-Image. + +**Code**: + +```hcl +# Marketplace-Element abrufen +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Bereitstellung aus dem Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Marketplace-Quelle + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Konfiguration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Erklärungen**: +- `marketplace_item_id`: Verweist auf ein einsatzbereites Image +- `datastore_id`: Spezifischer Datastore erforderlich für Marketplace-Bereitstellung +- Das Image enthält bereits ein konfiguriertes Betriebssystem + +--- + +### Eine VM aus der Content Library erstellen + +**Ziel**: Bereitstellen einer VM aus einer VMware Content Library-Vorlage. + +**Code**: + +```hcl +# Content Library abrufen +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Spezifisches Element abrufen +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Bereitstellung aus Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Content Library-Quelle + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # OS-Festplatten-Konfiguration + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # OS-Netzwerkadapter-Konfiguration + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Erklärungen**: +- Die Blöcke `os_disk` und `os_network_adapter` konfigurieren die Vorlagen-Ressourcen +- Diese Blöcke können nur bei der Erstellung verwendet werden (siehe dedizierter Abschnitt) + +--- + +### VMware Cloud-Init konfigurieren + +**Ziel**: VM-Konfiguration beim ersten Start mit Cloud-Init automatisieren. + +**Voraussetzungen**: Verwenden Sie ein Cloud-Init-kompatibles Image (z.B. Ubuntu Cloud Image im OVF-Format). + +**Cloud-Init-Dateien**: + +Create `cloud-init/user-data.yml`: + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Create `cloud-init/network-config.yml`: + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Terraform Code**: + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Cloud-Init configuration (VMware OVF datasource) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Unterstützte Cloud-Init-Schlüssel (VMware)**: +- `user-data`: Hauptkonfiguration (base64) +- `network-config`: Netzwerkkonfiguration (base64) +- `public-keys`: SSH Public Keys +- `hostname`: Hostname +- `password`: Passwort (oder "RANDOM") +- `instance-id`: Eindeutige Kennung +- `seedfrom`: URL der Konfigurationsquelle + +:::warning Einschränkung + Cloud-Init wird nur beim ersten VM-Start ausgeführt. +::: + +--- + +### Eine virtuelle Festplatte erstellen und an eine VM anhängen + +**Ziel**: Zusätzlichen Speicher zu einer bestehenden virtuellen Maschine hinzufügen. + +**Code**: + +```hcl +# Referenz auf eine bestehende VM +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Virtuelle Festplatte erstellen +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # An VM anhängen + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Festplattengröße + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Festplattenmodus + disk_mode = "persistent" + + # Bereitstellungstyp + provisioning_type = "dynamic" +} +``` + +**Verfügbare Festplattenmodi**: +- `persistent`: Änderungen werden sofort und dauerhaft auf der virtuellen Festplatte gespeichert. +- `independent_nonpersistent`: Änderungen an der virtuellen Festplatte werden in einem Redo-Log gespeichert und beim Ausschalten gelöscht. +- `independent_persistent`: Änderungen werden sofort und dauerhaft auf der virtuellen Festplatte gespeichert. Nicht von Snapshots betroffen. + +**Bereitstellungstypen**: +- `dynamic`: Spart Speicherplatz durch dynamische Zuordnung nach Bedarf. Erstellung ist schnell. +- `staticImmediate`: Reserviert den gesamten Festplattenspeicher bei der Erstellung, aber Blöcke werden beim ersten Schreiben genullt. +- `staticDiffered`: Reserviert und nullt den gesamten Festplattenspeicher bei der Erstellung. + +--- + +### Eine Netzwerkschnittstelle erstellen und an eine VM anhängen + +**Ziel**: Hinzufügen einer Netzwerkkarte zu einer virtuellen Maschine. + +**Code**: + +```hcl +# Netzwerk abrufen +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# VM-Referenz +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Netzwerkadapter erstellen +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # Ziel-VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Netzwerk + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Adaptertyp + type = "VMXNET3" + + # Automatisch beim Einschalten verbinden + connect_on_power_on = true + + # MAC-Adresse (optional, wird automatisch generiert, wenn weggelassen) + # mac_address = "00:50:56:xx:xx:xx" +} +``` + +:::info Unterstützte Netzwerkadaptertypen + Die kompatiblen Adaptertypen hängen vom verwendeten OS auf der Virtual Machine und der VMware-Version ab. +::: + +--- + +### Einen virtuellen Controller erstellen und an eine VM anhängen + +**Ziel**: Hinzufügen eines Festplatten-Controllers zu einer virtuellen Maschine. + +**Code**: + +```hcl +# VM-Referenz +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# SCSI-Controller erstellen +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # Ziel-VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Controller-Typ + type = "SCSI" +} +``` + +**Controller-Typen**: +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## OpenSource IaaS + +### Eine VM aus einer Vorlage erstellen + +**Ziel**: Bereitstellen einer virtuellen Maschine aus einer Katalogvorlage. + +**Voraussetzungen**: +- Zugriff auf Cloud Temple OpenSource-Infrastruktur +- Erforderliche Berechtigungen: + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code**: + +```hcl +# Vorlage abrufen +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Host abrufen +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Storage-Repository abrufen +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Netzwerk abrufen +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Backup-Policy abrufen +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# VM erstellen +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Quelle + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Hardware-Konfiguration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Optionen + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # OS-Festplatte (muss zur Vorlage passen) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # OS-Netzwerkadapter + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Backup + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Boot-Reihenfolge + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Erklärungen**: +- `high_availability`: Verfügbare Optionen: `disabled`, `restart`, `best-effort` (Siehe [Dokumentation](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) zur Hochverfügbarkeit) +- `boot_firmware`: `bios` oder `uefi` +- `secure_boot`: Nur mit UEFI + +--- + +### Eine VM aus dem Marketplace erstellen + +**Ziel**: Bereitstellen einer VM aus dem Cloud Temple Marketplace auf OpenSource IaaS. + +**Code**: + +```hcl +# Marketplace-Element abrufen +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Deploy from Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Marketplace source + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Replikation konfigurieren + +**Ziel**: Einrichten einer Replikations-Policy für eine VM. + +**Code**: + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Replikations-Policy erstellen +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Mit einer VM verknüpfen +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... Standardkonfiguration ... + + # Replikations-Policy zuweisen + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Erklärungen**: +- `interval`: Replikationsintervall. Kann in `minutes` oder `hours` angegeben werden +- `storage_repository_id`: Storage Repository, in das VM-Festplatten repliziert werden. Muss sich in einer anderen AZ als die Original-VM befinden + +--- + +### Backup konfigurieren + +**Ziel**: Eine Backup-Policy auf eine VM anwenden. + +**Code**: + +```hcl +# Backup-Policies abrufen +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM mit mehreren Backup-Policies +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... Standardkonfiguration ... + + # Mehrere Policies können angewendet werden + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Obligatorisches Backup + In einer SecNumCloud-Umgebung muss mindestens eine Backup-Policy definiert werden, um die VM zu starten. +::: + +--- + +### Hochverfügbarkeit konfigurieren + +**Ziel**: HA-Verhalten einer virtuellen Maschine konfigurieren. + +**Code**: + +```hcl +# VM mit deaktivierter HA +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM mit priorisiertem Neustart +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM mit Best-Effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Verfügbare HA-Modi**: + +Siehe Dokumentation zur [Hochverfügbarkeit](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) in der OpenSource-Infrastruktur + +| Modus | Beschreibung | Verwendung | +|------|-------------|-------| +| `disabled` | Keine HA | Entwicklungsumgebungen | +| `restart` | Neustart mit hoher Priorität | Kritische Produktion | +| `best-effort` | Neustart wenn Ressourcen verfügbar | Standard-Produktion | + +--- + +### OpenSource Cloud-Init konfigurieren + +**Ziel**: Konfiguration mit Cloud-Init automatisieren (NoCloud datasource). + +**Voraussetzungen**: Cloud-Init NoCloud kompatibles Image. + +**Cloud-Init-Dateien**: + +Erstellen Sie `cloud-init/cloud-config.yml`: + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Erstellen Sie `cloud-init/network-config.yml`: + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important Hinweis + Passen Sie die Cloud-Init-Konfiguration an Ihre Bedürfnisse und die auf Ihrer Maschine installierte Cloud-Init-Version an. Format und Syntax können je nach Version variieren. +::: + +**Terraform-Code**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Cloud-Init configuration (NoCloud datasource) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Unterschied zu VMware**: +- OpenSource verwendet die **NoCloud** Datenquelle +- Unterstützte Schlüssel: `cloud_config` und `network_config` +- Kein `filebase64()`, verwenden Sie direkt `file()` + +--- + +### os_disk und os_network_adapter verstehen + +Die Blöcke `os_disk` und `os_network_adapter` sind spezielle Blöcke, die **nur während der Erstellung** einer virtuellen Maschine verwendet werden können aus: + +- Content Library +- Vorlage +- Cloud Temple Marketplace +- Klon einer bestehenden VM + +:::info Info + Sie werden verwendet, um virtuelle Festplatten und Netzwerkadapter zu referenzieren, die von der Vorlage bereitgestellt werden, um deren Parameter später ändern zu können, ohne sie manuell importieren zu müssen. Sie erstellen in keiner Weise eine neue Ressource. +::: + +**Wichtige Merkmale**: + +1. **Nur bei Erstellung**: Diese Blöcke können nur während des ersten `terraform apply` definiert werden +2. **Alternative**: Verwenden Sie den Befehl `terraform import`, um sie manuell zu importieren + +--- + +### os_disk verwenden + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configure the existing OS disk in the template + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Resize to 100 GB + disk_mode = "persistent" + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # OS disk configuration + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... other configurations +} +``` + +--- + +### Using os_network_adapter + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configure the template network adapter + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Optional + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Network adapter configuration + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Optional + tx_checksumming = true + attached = true + } + + # ... other configurations +} +``` + +:::info Hinweis + Sie können beide Ansätze kombinieren, indem Sie die Festplatten und/oder Netzwerkadapter einer VM referenzieren und weitere über die Ressourcen `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` und `cloudtemple_compute_iaas_vmware/opensource_network_adapter` hinzufügen +::: + +--- + +**Best Practices**: +1. Verwenden Sie `os_disk` und `os_network_adapter` für die anfängliche Vorlagenkonfiguration +2. Verwenden Sie dedizierte Ressourcen, um zusätzliche Ressourcen hinzuzufügen + +--- + +## Objektspeicher + +### Einen Bucket erstellen + +**Ziel**: Einen S3-kompatiblen Objektspeicher-Bucket erstellen. + +**Voraussetzungen**: `object-storage_write` Berechtigung + +**Code**: + +```hcl +# Privater Bucket +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Öffentlicher Bucket +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket mit benutzerdefiniertem Zugriff (IP-Whitelist) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # IP/CIDR-Whitelist + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket mit aktivierter Versionierung +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Nützliche Outputs +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Zugriffstypen**: +- `private`: Zugriff beschränkt auf Tenant-IP-Adressen +- `public`: Öffentlicher Lesezugriff +- `custom`: Zugriff beschränkt auf Whitelist-IPs + +**Versionierung**: +- `Enabled`: Aktiviert Objektversionierung +- `Suspended`: Pausiert Versionierung (behält bestehende Versionen) + +--- + +### Ein Storage-Konto erstellen + +**Ziel**: Ein Storage-Konto mit S3-Anmeldeinformationen erstellen. + +**Code**: + +```hcl +# Storage-Konto erstellen +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Outputs zur Verwendung der Anmeldeinformationen +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Sensible Informationen + Anmeldeinformationen werden nur einmal angezeigt. Speichern Sie sie sicher (z.B. HashiCorp Vault, AWS Secrets Manager). +::: + +--- + +### ACLs über dedizierte Ressource erstellen + +**Ziel**: Bucket-Zugriffsberechtigungen mit ACLs verwalten. + +**Code**: + +```hcl +# Verfügbare Rollen abrufen +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Bestehende Storage-Konten abrufen +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL für Dev-Team (nur Lesen) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL für Ops-Team (Maintainer) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Verfügbare Rollen**: +- `read_write`: Lesen und Schreiben +- `write_only`: Nur Schreiben +- `read_only`: Nur Lesen +- `maintainer`: Vollzugriff + +--- + +### ACLs direkt im Bucket konfigurieren + +**Ziel**: ACLs beim Erstellen des Buckets definieren. + +**Code**: + +```hcl +# Ressourcen abrufen +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket mit Inline-ACLs +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # ACL-Definition im Bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Unterschied zu dedizierten ACL-Ressourcen**: +- **Inline**: ACLs direkt im Bucket definiert (einfacher für statische Konfigurationen) +- **Dedizierte Ressource**: ACLs separat verwaltet (flexibler, ermöglicht unabhängige Änderungen) + +--- + +### Datasources verwenden + +**Ziel**: Bucket-Metadaten abfragen und Dateien auflisten. + +**Code**: + +```hcl +# Datasource zum Auflisten von Bucket-Dateien +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Alle Dateien anzeigen +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Bestimmte Datei filtern +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Bestehendes Storage-Konto abrufen +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### S3-Integration mit AWS Provider + +**Ziel**: AWS Provider verwenden, um Dateien in Cloud Temple Objektspeicher hochzuladen. + +**Code**: + +```hcl +# Konto und Bucket erstellen +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# AWS Provider für Cloud Temple S3 konfigurieren +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Cloud Temple Anmeldeinformationen verwenden + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Cloud Temple Endpoint + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Konfiguration zum Überspringen der AWS-Validierung + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Datei hochladen +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Mehrere Dateien hochladen +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Hochgeladene Dateien überprüfen +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Fazit + +Diese Dokumentation deckt die wichtigsten Anwendungsfälle des Cloud Temple Terraform Providers ab. Um weiterzugehen: + +- Siehe die [offizielle Provider-Dokumentation](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Erkunden Sie die [Beispiele auf GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Verwenden Sie die [Cloud Temple Console](https://shiva.cloud-temple.com), um verfügbare Ressourcen zu identifizieren + +:::info Benötigen Sie Hilfe? + Bei Fragen oder Problemen siehe den [Issues-Bereich auf GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) oder kontaktieren Sie den Cloud Temple Support. +::: diff --git a/i18n/en/docusaurus-plugin-content-docs/current/terraform/concepts.md b/i18n/en/docusaurus-plugin-content-docs/current/terraform/concepts.md new file mode 100644 index 00000000..f8becfae --- /dev/null +++ b/i18n/en/docusaurus-plugin-content-docs/current/terraform/concepts.md @@ -0,0 +1,473 @@ +--- +title: Concepts +--- + +# Terraform Concepts in the Cloud Temple Provider + +This page presents the fundamental concepts necessary to understand and effectively use the Cloud Temple Terraform provider. + +## Infrastructure as Code (IaC) + +Infrastructure as Code is an approach that consists of managing and provisioning IT infrastructure through human-readable configuration files, rather than through manual configuration or interactive tools. + +### Advantages of IaC with Terraform + +- **Versioning**: Infrastructure is defined in files that can be versioned (Git) +- **Collaboration**: Teams can work together on the same infrastructure +- **Automation**: Reduction of human errors and time savings +- **Documentation**: Code explicitly describes the infrastructure +- **Reproducibility**: Deployment of identical environments in minutes + +## Terraform Provider + +A Terraform provider is a plugin that allows Terraform to interact with a specific API. The Cloud Temple provider acts as an abstraction layer between your Terraform configuration files and the Cloud Temple APIs. + +### Provider Declaration + +The provider must be declared in a `terraform` block with `required_providers`: + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Authentication + +The provider authenticates with Cloud Temple APIs using: + +1. **Client ID**: Unique identifier for your application +2. **Secret ID**: Secret key associated with the Client ID + +These credentials are generated from the Cloud Temple Console and allow the provider to perform operations on your behalf. + +:::info Best Practices + Store your credentials in environment variables or a secrets manager, never directly in the code. +::: + +## Resources + +A resource represents an infrastructure component that can be created, read, updated, or deleted (CRUD operations). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Cloud Temple Resource Types + +#### VMware IaaS + +- `cloudtemple_compute_virtual_machine`: Virtual machine +- `cloudtemple_compute_virtual_disk`: Virtual disk +- `cloudtemple_compute_network_adapter`: Network interface +- `cloudtemple_compute_virtual_controller`: Device controller + +#### OpenSource IaaS + +- `cloudtemple_compute_iaas_opensource_virtual_machine`: Virtual machine +- `cloudtemple_compute_iaas_opensource_virtual_disk`: Disk +- `cloudtemple_compute_iaas_opensource_network_adapter`: Network interface +- `cloudtemple_compute_iaas_opensource_replication_policy`: Replication policy + +#### Object Storage + +- `cloudtemple_object_storage_bucket`: S3 bucket +- `cloudtemple_object_storage_storage_account`: Storage account +- `cloudtemple_object_storage_acl_entry`: Bucket ACL +- `cloudtemple_object_storage_global_access_key`: Global access key to namespace + +### Attributes and Arguments + +Each resource has: + +- **Arguments**: Values you configure (inputs) +- **Attributes**: Values returned by the resource (outputs) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Arguments (configuration) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Attributes (automatically computed) + # id, moref, machine_manager_id, etc. +} + +# Reference to an attribute +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Datasources allow you to retrieve information about existing resources without managing them. They are **read-only**. + +### Using Datasources + +```hcl +# Retrieve an existing datacenter +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Retrieve a cluster +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Use in a resource +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Main Datasources + +You can find the complete list of available datasources in the Cloud Temple Terraform provider on [Terraform documentation](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Compute Infrastructure + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Virtual datacenter | +| `cloudtemple_compute_host_cluster` | Host cluster | +| `cloudtemple_compute_datastore_cluster` | Datastore cluster | +| `cloudtemple_compute_datastore` | Individual datastore | +| `cloudtemple_compute_network` | Network (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates and Marketplace + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_content_library` | Content library | +| `cloudtemple_compute_content_library_item` | Library item | +| `cloudtemple_marketplace_item` | Cloud Temple Marketplace item | +| `cloudtemple_compute_iaas_opensource_template` | Template in OpenSource IaaS catalog | + +#### Backup + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | VMware backup SLA policy | +| `cloudtemple_backup_iaas_opensource_policy` | OpenSource backup policy | + +#### Object Storage + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_object_storage_role` | Available roles for ACLs | +| `cloudtemple_object_storage_bucket_files` | Files in a bucket | +| `cloudtemple_object_storage_storage_account` | Existing storage account | + +## Terraform State + +The Terraform state is a file that maintains the mapping between your configuration and the actual resources in the cloud. + +### terraform.tfstate File + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Remote Backend + +For team collaboration, store the state in a remote backend: + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + The `terraform.tfstate` file contains sensitive information. Never commit it to Git and use a secure backend for storage. +::: + +:::info + OpenTofu offers state encryption by default ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: + +## Terraform Lifecycle + +### 1. Initialization (terraform init) + +Initialize the working directory and download the Cloud Temple provider: + +```bash +terraform init +``` + +This command: +- Downloads the provider from the Terraform Registry +- Initializes the backend (if configured) +- Creates the `.terraform/` directory + +### 2. Planning (terraform plan) + +Generate an execution plan showing the changes to be applied: + +```bash +terraform plan +``` + +The plan indicates: +- **Resources to create** (`+`) +- **Resources to modify** (`~`) +- **Resources to destroy** (`-`) +- **Resources to recreate** (`-/+`) + +### 3. Application (terraform apply) + +Apply changes to reach the desired state: + +```bash +terraform apply +``` + +Terraform: +1. Generates a plan +2. Asks for confirmation (unless `--auto-approve`) +3. Applies changes +4. Updates the state + +### 4. Destruction (terraform destroy) + +Destroy all managed resources: + +```bash +terraform destroy +``` + +:::danger Warning + This command permanently deletes all resources. Use with caution. +::: + +### 5. Other Useful Commands + +```bash +# Show current state +terraform show + +# List resources +terraform state list + +# Validate configuration +terraform validate + +# Format files +terraform fmt + +# Show outputs +terraform output +``` + +## Dependencies and Execution Order + +Terraform automatically analyzes dependencies between resources. + +### Implicit Dependencies + +Terraform detects references between resources: + +```hcl +# The datasource is evaluated first +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Then the VM is created (implicit dependency via datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Finally the disk is attached (dependency via virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Explicit Dependencies + +To force a specific order, use `depends_on`: + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variables and Outputs + +### Input Variables + +Make your configuration reusable: + +```hcl +variable "vm_name" { + description = "Virtual machine name" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Memory in GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Outputs + +Expose information after application: + +```hcl +output "vm_id" { + description = "Virtual machine ID" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "VMware Managed Object Reference" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Modules + +Modules allow you to group and reuse configurations: + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Best Practices + +### File Organization + +``` +. +├── main.tf # Main resources +├── variables.tf # Variable declarations +├── outputs.tf # Output declarations +├── versions.tf # Terraform and provider versions +├── terraform.tfvars # Variable values (do not commit) +└── modules/ # Reusable modules + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Secrets Management + +```hcl +# ❌ To avoid +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "plaintext-secret" +} + +# ✅ Recommended +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Using Tags + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Next Steps + +- [Getting Started Guide](quickstart.md): Create your first infrastructure with Terraform +- [Tutorials](tutorials.md): Practical examples for each service diff --git a/i18n/en/docusaurus-plugin-content-docs/current/terraform/quickstart.md b/i18n/en/docusaurus-plugin-content-docs/current/terraform/quickstart.md new file mode 100644 index 00000000..d43817ed --- /dev/null +++ b/i18n/en/docusaurus-plugin-content-docs/current/terraform/quickstart.md @@ -0,0 +1,566 @@ +--- +title: Getting Started +--- + +# Quick Start Guide + +This guide walks you through step-by-step to deploy your first Cloud Temple infrastructure with Terraform. + +## Prerequisites + +Before you begin, make sure you have: + +- An active Cloud Temple account +- Access to the [Cloud Temple Console](https://shiva.cloud-temple.com) +- API key (Client ID and Secret ID) +- Terraform installed on your machine (version 1.0 or higher) + +## Step 1: Install Terraform + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Download the executable from [terraform.io](https://www.terraform.io/downloads) or use Chocolatey: + +```powershell +choco install terraform +``` + +### Installation Verification + +```bash +terraform version +``` + +You should see output similar to: + +``` +Terraform v1.6.0 +``` + +## Step 2: Get Your API Key + +### Generating an API Key in the Console + +These credentials can be generated from the Cloud Temple Console by following [this procedure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +:::warning Security + Keep these credentials safe. The Secret ID will only be displayed once. +::: + +### Configuring Environment Variables + +Export your credentials as environment variables: + +**Linux/macOS:** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell):** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Step 3: Create Your Terraform Project + +### Create the Project Directory + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Create the Provider Configuration File + +Create a `versions.tf` file: + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Credentials are automatically retrieved from environment variables + # CLOUDTEMPLE_CLIENT_ID and CLOUDTEMPLE_SECRET_ID +} +``` + +## Step 4: Initialize Terraform + +Initialize your Terraform project to download the provider: + +```bash +terraform init +``` + +You should see: + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Step 5: Create Your First Resource + +### Simple Example: VMware Virtual Machine + +Create a `main.tf` file with a minimal configuration: + +```hcl +# Retrieving necessary existing resources +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Adapt with your vCenter name +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Adapt with your datacenter name + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Adapt with your cluster name + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Adapt with your datastore cluster name + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Backup policy +} + +# Creating a virtual machine +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Hardware configuration + memory = 4 * 1024 * 1024 * 1024 # 4 GB in bytes + cpu = 2 + num_cores_per_socket = 1 + + # Flexibility options + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Location + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Operating system + guest_operating_system_moref = "ubuntu64Guest" + + # Backup policy + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tags + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output to display VM ID +output "vm_id" { + description = "ID of the created virtual machine" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference of the VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Adapting Names + The names of datacenters, clusters, and datastores must match those available in your Cloud Temple environment. Check the console to identify available resources. +::: + +## Step 6: Plan the Changes + +Before applying the changes, visualize what will be created: + +```bash +terraform plan +``` + +Terraform displays a detailed plan: + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Step 7: Apply the Configuration + +Deploy your infrastructure: + +```bash +terraform apply +``` + +Terraform asks for confirmation: + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Type `yes` and press Enter. + +Terraform creates the resources: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success Congratulations! + You just created your first Cloud Temple virtual machine with Terraform! +::: + +## Step 8: Verify the Creation + +### In the Cloud Temple Console + +1. Log in to the [Cloud Temple Console](https://shiva.cloud-temple.com) +2. Navigate to **IaaS VMWare** > **Virtual Machines** +3. You should see your Virtual Machine `terraform-vm-01` + +### With Terraform + +Display the current state: + +```bash +terraform show +``` + +List managed resources: + +```bash +terraform state list +``` + +Display outputs: + +```bash +terraform output +``` + +## Step 9: Modify Your Infrastructure + +Modify the `main.tf` file to increase memory to 8 GB: + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB instead of 4 GB + cpu = 2 + # ... rest of the configuration +} +``` + +Plan and apply the changes: + +```bash +terraform plan +terraform apply +``` + +Terraform detects the modification and updates the VM: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (other attributes unchanged) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Step 10: Destroy Resources + +When you're done testing, delete the created resources: + +```bash +terraform destroy +``` + +Terraform displays what will be deleted and asks for confirmation: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Type `yes` to confirm deletion. + +## Recommended Project Structure + +For more complex projects, organize your files as follows: + +``` +terraform-cloudtemple/ +├── main.tf # Main resources +├── versions.tf # Provider configuration +├── variables.tf # Variable declarations +├── outputs.tf # Output declarations +├── terraform.tfvars # Variable values (do not version) +├── .gitignore # Git exclusions +└── README.md # Project documentation +``` + +### Example .gitignore + +```gitignore +# Terraform files +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# Crash files +crash.log +crash.*.log + +# Sensitive variable files +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Essential Terraform Commands + +| Command | Description | +|---------|-------------| +| `terraform init` | Initialize the working directory | +| `terraform validate` | Validate configuration syntax | +| `terraform fmt` | Automatically format files | +| `terraform plan` | Display execution plan | +| `terraform apply` | Apply changes | +| `terraform destroy` | Destroy all resources | +| `terraform show` | Display current state | +| `terraform output` | Display output values | +| `terraform state list` | List managed resources | + +## Best Practices + +### 1. Use Variables + +```hcl +# variables.tf +variable "environment" { + description = "Deployment environment" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Organize with Modules + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Use a Remote Backend + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Comment Your Code + +```hcl +# Virtual machine for production web server +# CPU and memory sized to handle 1000 req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Hardware configuration based on internal benchmarks + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Use Datasources + +Don't recreate what already exists. Use datasources to reference existing resources: + +```hcl +# Reference an existing network +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Troubleshooting + +### Error: "Error: Failed to query available provider packages" + +**Cause**: Connection problem to Terraform Registry. + +**Solution**: Check your internet connection and retry `terraform init`. + +### Error: "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Cause**: Invalid or expired credentials. + +**Solution**: +1. Check your environment variables +2. Generate a new API key in the console +3. Verify your API key permissions + +### Error: "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Cause**: The referenced resource (datacenter, cluster, etc.) doesn't exist or you don't have access to it. + +**Solution**: +1. Check the exact name (or uuid) in the Cloud Temple console +2. Verify your access rights to this resource + +## Next Steps + +Now that you've mastered the basics, explore advanced tutorials: + +- [VMware IaaS Tutorials](tutorials.md#iaas-vmware): Advanced VM deployment, disk management, network configuration +- [OpenSource IaaS Tutorials](tutorials.md#iaas-opensource): XCP-ng virtual machines, replication, high availability +- [Object Storage Tutorials](tutorials.md#object-storage): Bucket creation, ACL management, S3 integration + +## Additional Resources + +- [Terraform Registry - Cloud Temple Provider](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Cloud Temple Console](https://shiva.cloud-temple.com) +- [Cloud Temple Terraform Concepts](concepts.md) diff --git a/i18n/en/docusaurus-plugin-content-docs/current/terraform/terraform.md b/i18n/en/docusaurus-plugin-content-docs/current/terraform/terraform.md new file mode 100644 index 00000000..80fa186a --- /dev/null +++ b/i18n/en/docusaurus-plugin-content-docs/current/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Overview +--- + +The Cloud Temple Terraform provider allows you to manage your Cloud Temple account infrastructure using the Infrastructure as Code (IaC) approach. It offers complete integration with Cloud Temple infrastructure services, enabling you to provision, configure, and manage your cloud resources in a declarative and reproducible manner. + +## Key Features + +- **Infrastructure as Code**: Define your infrastructure in versionable configuration files +- **Declarative Management**: Describe the desired state of your infrastructure, Terraform handles the rest +- **Complete Automation**: Automate the provisioning and management of your resources +- **Reproducibility**: Deploy identical environments reliably +- **Dependency Management**: Terraform automatically manages resource creation order + +## Covered Products + +The Cloud Temple Terraform provider supports the following services: + +### VMware IaaS + +Manage your VMware virtual machines with all advanced virtualization features: + +- **Virtual Machines**: Virtual machine creation and configuration +- **Virtual Disks**: Virtual disk creation and configuration +- **Network Adapters**: Virtual machine network adapter management +- **Virtual Controllers**: Disk controller and other device management +- **Cloud-Init**: Automated startup configuration +- **Backup**: Integration with Cloud Temple backup policies + +### OpenSource IaaS + +Provision and manage virtual machines on OpenSource infrastructure based on XCP-ng: + +- **Virtual Machines**: Virtual machine creation and management +- **Virtual Disks**: Virtual disk creation and configuration +- **Network Adapters**: Virtual machine network adapter creation and configuration +- **Replication**: Data replication policies +- **High Availability**: HA configuration (disabled, restart, best-effort) +- **Cloud-Init**: NoCloud-compatible automated configuration +- **Backup**: Integration with Cloud Temple backup policies + +### Object Storage + +Manage your S3-compatible object storage spaces: + +- **Buckets**: Bucket creation and configuration +- **Storage Accounts**: S3 identity and credential management +- **ACL**: Granular bucket access control +- **Versioning**: Object version management + +## Prerequisites + +Before using the Cloud Temple Terraform provider, ensure you have: + +### Cloud Temple Console Access + +You must have access to the [Cloud Temple Console](https://shiva.cloud-temple.com) with appropriate rights on the tenant you wish to work on. + +### API Key + +The provider requires Cloud Temple API credentials: + +- **Client ID**: Client identifier for authentication +- **Secret ID**: Secret associated with the client ID + +These credentials can be generated from the Cloud Temple Console by following [this procedure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +### Rights and Permissions + +Depending on the resources you want to manage, you must have the appropriate roles: + +#### For VMware IaaS + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` and `backup_iaas_spp_write` (for backup) + +#### For OpenSource IaaS + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` and `backup_iaas_opensource_write` (for backup) + +#### For Object Storage + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Common Rights + +- `activity_read` +- `tag_read` and `tag_write` + +## Terraform Compatibility + +The Cloud Temple provider is compatible with: + +- **Terraform**: Version 1.0 and above +- **OpenTofu**: Compatible with recent versions + +## Logging and Debugging + +To enable detailed provider logging: + +```bash +# DEBUG level logging +export TF_LOG=DEBUG +terraform apply + +# JSON format logging +export TF_LOG=JSON +terraform apply + +# Save logs to a file +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Support and Resources + +- **Official Documentation**: [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Source Code**: [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues**: [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Next Steps + +- [Concepts](concepts.md): Understand key provider concepts +- [Getting Started Guide](quickstart.md): Create your first infrastructure +- [Tutorials](tutorials.md): Practical examples and use cases diff --git a/i18n/en/docusaurus-plugin-content-docs/current/terraform/tutorials.md b/i18n/en/docusaurus-plugin-content-docs/current/terraform/tutorials.md new file mode 100644 index 00000000..b27600f2 --- /dev/null +++ b/i18n/en/docusaurus-plugin-content-docs/current/terraform/tutorials.md @@ -0,0 +1,1306 @@ +--- +title: Tutorials +--- + +# Cloud Temple Terraform Tutorials + +This page contains practical tutorials for using the Cloud Temple Terraform provider with different services. + +## Table of Contents + +- [VMware IaaS](#vmware-iaas) +- [OpenSource IaaS](#opensource-iaas) +- [Object Storage](#object-storage) + +## VMware IaaS + +### Create an Empty VM + +**Objective**: Create a basic VMware virtual machine without an operating system. + +**Prerequisites**: +- Access to a Cloud Temple datacenter +- Configured API credentials +- Required permissions: + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code**: + +```hcl +# Retrieve required resources +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Create an empty VM +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Hardware configuration + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-add enabled + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Location + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Guest operating system + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Explanations**: +- `guest_operating_system_moref`: Defines the OS type for VMware Tools drivers +- The VM is created without disk or network (to be added separately) +- Hot-add options allow adding CPU/RAM on the fly + +--- + +### Create a VM from the Marketplace + +**Objective**: Deploy a VM from a Cloud Temple Marketplace image. + +**Code**: + +```hcl +# Retrieve a Marketplace item +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Deploy from Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Marketplace source + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Configuration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Explanations**: +- `marketplace_item_id`: References a ready-to-use image +- `datastore_id`: Specific datastore required for Marketplace deployment +- The image already includes a configured operating system + +--- + +### Create a VM from Content Library + +**Objective**: Deploy a VM from a VMware Content Library template. + +**Code**: + +```hcl +# Retrieve the Content Library +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Retrieve a specific item +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Deploy from Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Content Library source + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # OS disk configuration + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # OS network adapter configuration + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Explanations**: +- The `os_disk` and `os_network_adapter` blocks configure the template resources +- These blocks can only be used at creation time (see dedicated section) + +--- + +### Configure VMware Cloud-Init + +**Objective**: Automate VM configuration at first boot with Cloud-Init. + +**Prerequisites**: Use a Cloud-Init compatible image (e.g., Ubuntu Cloud Image in OVF format). + +**Cloud-Init Files**: + +Create `cloud-init/user-data.yml`: + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Create `cloud-init/network-config.yml`: + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Terraform Code**: + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Cloud-Init configuration (VMware OVF datasource) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Supported Cloud-Init keys (VMware)**: +- `user-data`: Main configuration (base64) +- `network-config`: Network configuration (base64) +- `public-keys`: SSH public keys +- `hostname`: Hostname +- `password`: Password (or "RANDOM") +- `instance-id`: Unique identifier +- `seedfrom`: Configuration source URL + +:::warning Limitation + Cloud-Init is only executed at first VM boot. +::: + +--- + +### Create a virtual disk and attach it to a VM + +**Objective**: Add additional storage to an existing virtual machine. + +**Code**: + +```hcl +# Reference an existing VM +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Create a virtual disk +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # Attach to VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Disk size + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Disk mode + disk_mode = "persistent" + + # Provisioning type + provisioning_type = "dynamic" +} +``` + +**Available disk modes**: +- `persistent`: Changes are immediately and permanently saved to the virtual disk. +- `independent_nonpersistent`: Changes made to the virtual disk are saved in a redo log and deleted on power off. +- `independent_persistent`: Changes are immediately and permanently saved to the virtual disk. Not affected by snapshots. + +**Provisioning types**: +- `dynamic`: Saves storage space by dynamically allocating space as needed. Creation is fast. +- `staticImmediate`: Allocates all disk space on creation, but blocks are zeroed out on first write. +- `staticDiffered`: Allocates and zeros out all disk space on creation. + +--- + +### Create a network interface and attach it to a VM + +**Objective**: Add a network card to a virtual machine. + +**Code**: + +```hcl +# Retrieve the network +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# Reference the VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Create a network adapter +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # Target VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Network + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Adapter type + type = "VMXNET3" + + # Auto-connect on power on + connect_on_power_on = true + + # MAC address (optional, generated automatically if omitted) + # mac_address = "00:50:56:xx:xx:xx" +} +``` + +:::info Supported network adapter types + The compatible adapter types that can be used depend on the OS used on the Virtual Machine and the VMware version. +::: + +--- + +### Create a virtual controller and attach it to a VM + +**Objective**: Add a disk controller to a virtual machine. + +**Code**: + +```hcl +# Reference the VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Create a SCSI controller +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # Target VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Controller type + type = "SCSI" +} +``` + +**Controller types**: +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## OpenSource IaaS + +### Create a VM from a template + +**Objective**: Deploy a virtual machine from a catalog template. + +**Prerequisites**: +- Access to Cloud Temple OpenSource infrastructure +- Required permissions: + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code**: + +```hcl +# Retrieve a template +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Retrieve the host +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Retrieve the storage repository +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Retrieve the network +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Retrieve the backup policy +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# Create the VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Source + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Hardware configuration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Options + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # OS disk (must match template) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # OS network adapter + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Backup + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Boot order + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Explanations**: +- `high_availability`: Available options: `disabled`, `restart`, `best-effort` (See [documentation](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) on High Availability) +- `boot_firmware`: `bios` or `uefi` +- `secure_boot`: Only with UEFI + +--- + +### Create a VM from the Marketplace + +**Objective**: Deploy a VM from the Cloud Temple Marketplace on OpenSource IaaS. + +**Code**: + +```hcl +# Retrieve a Marketplace item +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Deploy from Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Marketplace source + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Configure Replication + +**Objective**: Set up a replication policy for a VM. + +**Code**: + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Create a replication policy +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Associate with a VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... standard configuration ... + + # Associate the replication policy + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Explanations**: +- `interval`: Replication interval. Can be specified in `minutes` or `hours` +- `storage_repository_id`: Storage Repository to which VM disks will be replicated. Must be on a different AZ than the original VM + +--- + +### Configure Backup + +**Objective**: Apply a backup policy to a VM. + +**Code**: + +```hcl +# Retrieve backup policies +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM with multiple backup policies +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... standard configuration ... + + # Multiple policies can be applied + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Mandatory backup + In a SecNumCloud environment, at least one backup policy must be defined to start the VM. +::: + +--- + +### Configure High Availability + +**Objective**: Configure HA behavior of a virtual machine. + +**Code**: + +```hcl +# VM with HA disabled +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM with priority restart +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM with best-effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Available HA modes**: + +See documentation on [High Availability](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) in OpenSource infrastructure + +| Mode | Description | Usage | +|------|-------------|-------| +| `disabled` | No HA | Development environments | +| `restart` | High priority restart | Critical production | +| `best-effort` | Restart if resources available | Standard production | + +--- + +### Configure OpenSource Cloud-Init + +**Objective**: Automate configuration with Cloud-Init (NoCloud datasource). + +**Prerequisites**: Cloud-Init NoCloud compatible image. + +**Cloud-Init Files**: + +Create `cloud-init/cloud-config.yml`: + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Create `cloud-init/network-config.yml`: + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important Note + Adapt the cloud-init configuration to your needs and the version of Cloud-Init installed on your machine. Format and syntax may change depending on versions. +::: + +**Terraform Code**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Cloud-Init configuration (NoCloud datasource) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Difference with VMware**: +- OpenSource uses the **NoCloud** datasource +- Supported keys: `cloud_config` and `network_config` +- No `filebase64()`, use `file()` directly + +--- + +### Understanding os_disk and os_network_adapter + +The `os_disk` and `os_network_adapter` blocks are special blocks usable **only during creation** of a virtual machine from: + +- Content Library +- Template +- Cloud Temple Marketplace +- Clone of an existing VM + +:::info info + They are used to reference virtual disks and network adapters deployed by the template to be able to modify their parameters later without having to import them manually. They do not create a new resource in any way. +::: + +**Important characteristics**: + +1. **Creation only**: These blocks can only be defined during the initial `terraform apply` +2. **Alternative**: Use the `terraform import` command to import them manually + +--- + +### Using os_disk + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configure the existing OS disk in the template + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Resize to 100 GB + disk_mode = "persistent" + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # OS disk configuration + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... other configurations +} +``` + +--- + +### Using os_network_adapter + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configure the template network adapter + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Optional + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Network adapter configuration + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Optional + tx_checksumming = true + attached = true + } + + # ... other configurations +} +``` + +:::info Note + You can combine both approaches by referencing the disks and/or network adapters of a VM and adding others via the `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` and `cloudtemple_compute_iaas_vmware/opensource_network_adapter` resources +::: + +--- + +**Best practices**: +1. Use `os_disk` and `os_network_adapter` for initial template configuration +2. Use dedicated resources to add additional resources + +--- + +## Object Storage + +### Create a bucket + +**Objective**: Create an S3-compatible object storage bucket. + +**Prerequisites**: `object-storage_write` permission + +**Code**: + +```hcl +# Private bucket +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Public bucket +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket with custom access (IP whitelist) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # IP/CIDR whitelist + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket with versioning enabled +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Useful outputs +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Access types**: +- `private`: Access restricted to tenant IP addresses +- `public`: Public read access +- `custom`: Access limited to whitelist IPs + +**Versioning**: +- `Enabled`: Enables object versioning +- `Suspended`: Suspends versioning (keeps existing versions) + +--- + +### Create a storage account + +**Objective**: Create a storage account with S3 credentials. + +**Code**: + +```hcl +# Create a storage account +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Outputs to use credentials +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Sensitive information + Credentials are displayed only once. Store them securely (e.g., HashiCorp Vault, AWS Secrets Manager). +::: + +--- + +### Create ACLs via dedicated resource + +**Objective**: Manage bucket access permissions with ACLs. + +**Code**: + +```hcl +# Retrieve available roles +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Retrieve existing storage accounts +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL for dev team (read only) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL for ops team (maintainer) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Available roles**: +- `read_write`: Read and write +- `write_only`: Write only +- `read_only`: Read only +- `maintainer`: Full access + +--- + +### Configure ACLs directly in the bucket + +**Objective**: Define ACLs when creating the bucket. + +**Code**: + +```hcl +# Retrieve resources +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket with inline ACLs +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # ACL definition in bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Difference with dedicated ACL resources**: +- **Inline**: ACLs defined directly in the bucket (simpler for static configurations) +- **Dedicated resource**: ACLs managed separately (more flexible, allows independent modifications) + +--- + +### Using datasources + +**Objective**: Query bucket metadata and list files. + +**Code**: + +```hcl +# Datasource to list bucket files +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Display all files +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Filter a specific file +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Retrieve an existing storage account +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### S3 Integration with AWS provider + +**Objective**: Use the AWS provider to upload files to Cloud Temple object storage. + +**Code**: + +```hcl +# Create account and bucket +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# Configure AWS provider for Cloud Temple S3 +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Use Cloud Temple credentials + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Cloud Temple endpoint + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Configuration to skip AWS validation + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Upload a file +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Upload multiple files +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Verify uploaded files +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Conclusion + +This documentation covers the main use cases of the Cloud Temple Terraform provider. To go further: + +- See the [official provider documentation](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Explore the [examples on GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Use the [Cloud Temple Console](https://shiva.cloud-temple.com) to identify available resources + +:::info Need help? + For any questions or issues, see the [Issues section on GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) or contact Cloud Temple support. +::: diff --git a/i18n/es/docusaurus-plugin-content-docs/current/terraform/concepts.md b/i18n/es/docusaurus-plugin-content-docs/current/terraform/concepts.md new file mode 100644 index 00000000..18cab0aa --- /dev/null +++ b/i18n/es/docusaurus-plugin-content-docs/current/terraform/concepts.md @@ -0,0 +1,473 @@ +--- +title: Conceptos +--- + +# Conceptos de Terraform en el proveedor Cloud Temple + +Esta página presenta los conceptos fundamentales necesarios para comprender y utilizar eficazmente el proveedor Terraform Cloud Temple. + +## Infraestructura como Código (IaC) + +La Infraestructura como Código es un enfoque que consiste en gestionar y aprovisionar la infraestructura informática a través de archivos de configuración legibles por humanos, en lugar de mediante configuración manual o herramientas interactivas. + +### Ventajas de IaC con Terraform + +- **Versionado**: La infraestructura se define en archivos que pueden ser versionados (Git) +- **Colaboración**: Los equipos pueden trabajar juntos en la misma infraestructura +- **Automatización**: Reducción de errores humanos y ahorro de tiempo +- **Documentación**: El código describe explícitamente la infraestructura +- **Reproducibilidad**: Despliegue de entornos idénticos en pocos minutos + +## Proveedor Terraform + +Un proveedor Terraform es un plugin que permite a Terraform interactuar con una API específica. El proveedor Cloud Temple actúa como una capa de abstracción entre sus archivos de configuración Terraform y las APIs Cloud Temple. + +### Declaración del proveedor + +El proveedor debe declararse en un bloque `terraform` con `required_providers`: + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Autenticación + +El proveedor se autentica con las APIs Cloud Temple utilizando: + +1. **Client ID**: Identificador único de su aplicación +2. **Secret ID**: Clave secreta asociada con el Client ID + +Estas credenciales se generan desde la Consola Cloud Temple y permiten al proveedor realizar operaciones en su nombre. + +:::info Buenas prácticas + Almacene sus credenciales en variables de entorno o un gestor de secretos, nunca directamente en el código. +::: + +## Recursos + +Un recurso representa un componente de infraestructura que puede ser creado, leído, actualizado o eliminado (operaciones CRUD). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Tipos de recursos Cloud Temple + +#### IaaS VMware + +- `cloudtemple_compute_virtual_machine`: Máquina virtual +- `cloudtemple_compute_virtual_disk`: Disco virtual +- `cloudtemple_compute_network_adapter`: Interfaz de red +- `cloudtemple_compute_virtual_controller`: Controlador de dispositivo + +#### IaaS OpenSource + +- `cloudtemple_compute_iaas_opensource_virtual_machine`: Máquina virtual +- `cloudtemple_compute_iaas_opensource_virtual_disk`: Disco +- `cloudtemple_compute_iaas_opensource_network_adapter`: Interfaz de red +- `cloudtemple_compute_iaas_opensource_replication_policy`: Política de replicación + +#### Object Storage + +- `cloudtemple_object_storage_bucket`: Bucket S3 +- `cloudtemple_object_storage_storage_account`: Cuenta de almacenamiento +- `cloudtemple_object_storage_acl_entry`: ACL de un bucket +- `cloudtemple_object_storage_global_access_key`: Clave de acceso global al namespace + +### Atributos y argumentos + +Cada recurso tiene: + +- **Argumentos**: Valores que usted configura (entradas) +- **Atributos**: Valores devueltos por el recurso (salidas) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Argumentos (configuración) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Atributos (calculados automáticamente) + # id, moref, machine_manager_id, etc. +} + +# Referencia a un atributo +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Los datasources permiten recuperar información sobre recursos existentes sin gestionarlos. Son de **solo lectura**. + +### Uso de datasources + +```hcl +# Recuperación de un datacenter existente +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Recuperación de un clúster +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Uso en un recurso +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Datasources principales + +Puede encontrar la lista completa de datasources disponibles en el proveedor Terraform Cloud Temple en [documentación Terraform](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Infraestructura Compute + +| Datasource | Descripción | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Datacenter virtual | +| `cloudtemple_compute_host_cluster` | Clúster de hosts | +| `cloudtemple_compute_datastore_cluster` | Clúster de datastores | +| `cloudtemple_compute_datastore` | Datastore individual | +| `cloudtemple_compute_network` | Red (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates y Marketplace + +| Datasource | Descripción | +|------------|-------------| +| `cloudtemple_compute_content_library` | Biblioteca de contenido | +| `cloudtemple_compute_content_library_item` | Elemento de biblioteca | +| `cloudtemple_marketplace_item` | Elemento de Marketplace Cloud Temple | +| `cloudtemple_compute_iaas_opensource_template` | Template en el catálogo IaaS OpenSource | + +#### Backup + +| Datasource | Descripción | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | Política SLA de backup VMware | +| `cloudtemple_backup_iaas_opensource_policy` | Política de backup OpenSource | + +#### Object Storage + +| Datasource | Descripción | +|------------|-------------| +| `cloudtemple_object_storage_role` | Roles disponibles para ACLs | +| `cloudtemple_object_storage_bucket_files` | Archivos en un bucket | +| `cloudtemple_object_storage_storage_account` | Cuenta de almacenamiento existente | + +## Estado Terraform (State) + +El state Terraform es un archivo que mantiene la correspondencia entre su configuración y los recursos reales en la nube. + +### Archivo terraform.tfstate + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Backend remoto + +Para trabajo en equipo, almacene el state en un backend remoto: + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + El archivo `terraform.tfstate` contiene información sensible. Nunca lo haga commit en Git y utilice un backend seguro para el almacenamiento. +::: + +:::info + OpenTofu proporciona cifrado del state por defecto ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: + +## Ciclo de vida Terraform + +### 1. Inicialización (terraform init) + +Inicializa el directorio de trabajo y descarga el proveedor Cloud Temple: + +```bash +terraform init +``` + +Este comando: +- Descarga el proveedor desde Terraform Registry +- Inicializa el backend (si está configurado) +- Crea el directorio `.terraform/` + +### 2. Planificación (terraform plan) + +Genera un plan de ejecución mostrando los cambios que se aplicarán: + +```bash +terraform plan +``` + +El plan indica: +- **Recursos a crear** (`+`) +- **Recursos a modificar** (`~`) +- **Recursos a destruir** (`-`) +- **Recursos a recrear** (`-/+`) + +### 3. Aplicación (terraform apply) + +Aplica los cambios para alcanzar el estado deseado: + +```bash +terraform apply +``` + +Terraform: +1. Genera un plan +2. Solicita confirmación (excepto con `--auto-approve`) +3. Aplica los cambios +4. Actualiza el state + +### 4. Destrucción (terraform destroy) + +Destruye todos los recursos gestionados: + +```bash +terraform destroy +``` + +:::danger Atención + Este comando elimina permanentemente todos los recursos. Úselo con precaución. +::: + +### 5. Otros comandos útiles + +```bash +# Mostrar el estado actual +terraform show + +# Listar recursos +terraform state list + +# Verificar la configuración +terraform validate + +# Formatear archivos +terraform fmt + +# Mostrar outputs +terraform output +``` + +## Dependencias y orden de ejecución + +Terraform analiza automáticamente las dependencias entre recursos. + +### Dependencias implícitas + +Terraform detecta referencias entre recursos: + +```hcl +# El datasource se evalúa primero +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Luego se crea la VM (dependencia implícita vía datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Finalmente se adjunta el disco (dependencia vía virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Dependencias explícitas + +Para forzar un orden específico, use `depends_on`: + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variables y outputs + +### Variables de entrada + +Hacen que su configuración sea reutilizable: + +```hcl +variable "vm_name" { + description = "Nombre de la máquina virtual" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Memoria en GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Outputs + +Exponen información después de la aplicación: + +```hcl +output "vm_id" { + description = "ID de la máquina virtual" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "Managed Object Reference VMware" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Módulos + +Los módulos permiten agrupar y reutilizar configuraciones: + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Buenas prácticas + +### Organización de archivos + +``` +. +├── main.tf # Recursos principales +├── variables.tf # Declaraciones de variables +├── outputs.tf # Declaraciones de outputs +├── versions.tf # Versiones Terraform y proveedores +├── terraform.tfvars # Valores de variables (no hacer commit) +└── modules/ # Módulos reutilizables + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Gestión de secretos + +```hcl +# ❌ A evitar +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "secreto-en-claro" +} + +# ✅ Recomendado +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Uso de tags + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Próximos pasos + +- [Guía de inicio](quickstart.md): Cree su primera infraestructura con Terraform +- [Tutoriales](tutorials.md): Ejemplos prácticos para cada servicio diff --git a/i18n/es/docusaurus-plugin-content-docs/current/terraform/quickstart.md b/i18n/es/docusaurus-plugin-content-docs/current/terraform/quickstart.md new file mode 100644 index 00000000..233cb196 --- /dev/null +++ b/i18n/es/docusaurus-plugin-content-docs/current/terraform/quickstart.md @@ -0,0 +1,566 @@ +--- +title: Guía de inicio +--- + +# Guía de inicio rápido + +Esta guía le acompaña paso a paso para desplegar su primera infraestructura Cloud Temple con Terraform. + +## Requisitos previos + +Antes de comenzar, asegúrese de tener: + +- Una cuenta Cloud Temple activa +- Acceso a la [Consola Cloud Temple](https://shiva.cloud-temple.com) +- Clave API (Client ID y Secret ID) +- Terraform instalado en su máquina (versión 1.0 o superior) + +## Paso 1: Instalar Terraform + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Descargue el ejecutable desde [terraform.io](https://www.terraform.io/downloads) o utilice Chocolatey: + +```powershell +choco install terraform +``` + +### Verificación de la instalación + +```bash +terraform version +``` + +Debería ver una salida similar a: + +``` +Terraform v1.6.0 +``` + +## Paso 2: Obtener su clave API + +### Generación de una clave API en la consola + +Estas credenciales pueden generarse desde la Consola Cloud Temple siguiendo [este procedimiento](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +:::warning Seguridad + Guarde estas credenciales en un lugar seguro. El Secret ID solo se mostrará una vez. +::: + +### Configuración de variables de entorno + +Exporte sus credenciales como variables de entorno: + +**Linux/macOS:** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell):** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Paso 3: Crear su proyecto Terraform + +### Crear el directorio del proyecto + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Crear el archivo de configuración del proveedor + +Cree un archivo `versions.tf`: + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Las credenciales se recuperan automáticamente de las variables de entorno + # CLOUDTEMPLE_CLIENT_ID y CLOUDTEMPLE_SECRET_ID +} +``` + +## Paso 4: Inicializar Terraform + +Inicialice su proyecto Terraform para descargar el proveedor: + +```bash +terraform init +``` + +Debería ver: + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Paso 5: Crear su primer recurso + +### Ejemplo simple: Máquina virtual VMware + +Cree un archivo `main.tf` con una configuración mínima: + +```hcl +# Recuperación de recursos existentes necesarios +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Adapte con el nombre de su vCenter +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Adapte con el nombre de su datacenter + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Adapte con el nombre de su clúster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Adapte con el nombre de su clúster de datastore + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Política de backup +} + +# Creación de una máquina virtual +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Configuración hardware + memory = 4 * 1024 * 1024 * 1024 # 4 GB en bytes + cpu = 2 + num_cores_per_socket = 1 + + # Opciones de flexibilidad + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Ubicación + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Sistema operativo + guest_operating_system_moref = "ubuntu64Guest" + + # Política de backup + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tags + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output para mostrar el ID de la VM +output "vm_id" { + description = "ID de la máquina virtual creada" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference de la VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Adaptación de nombres + Los nombres de los datacenters, clústeres y datastores deben coincidir con los disponibles en su entorno Cloud Temple. Consulte la consola para identificar los recursos disponibles. +::: + +## Paso 6: Planificar los cambios + +Antes de aplicar los cambios, visualice lo que se creará: + +```bash +terraform plan +``` + +Terraform muestra un plan detallado: + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Paso 7: Aplicar la configuración + +Despliegue su infraestructura: + +```bash +terraform apply +``` + +Terraform solicita confirmación: + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Escriba `yes` y presione Enter. + +Terraform crea los recursos: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success ¡Felicitaciones! + ¡Acaba de crear su primera máquina virtual Cloud Temple con Terraform! +::: + +## Paso 8: Verificar la creación + +### En la consola Cloud Temple + +1. Inicie sesión en la [Consola Cloud Temple](https://shiva.cloud-temple.com) +2. Navegue a **IaaS VMWare** > **Máquinas virtuales** +3. Debería ver su Máquina Virtual `terraform-vm-01` + +### Con Terraform + +Mostrar el estado actual: + +```bash +terraform show +``` + +Listar recursos gestionados: + +```bash +terraform state list +``` + +Mostrar outputs: + +```bash +terraform output +``` + +## Paso 9: Modificar su infraestructura + +Modifique el archivo `main.tf` para aumentar la memoria a 8 GB: + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB en lugar de 4 GB + cpu = 2 + # ... resto de la configuración +} +``` + +Planifique y aplique los cambios: + +```bash +terraform plan +terraform apply +``` + +Terraform detecta la modificación y actualiza la VM: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (otros atributos sin cambios) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Paso 10: Destruir recursos + +Cuando haya terminado sus pruebas, elimine los recursos creados: + +```bash +terraform destroy +``` + +Terraform muestra lo que se eliminará y solicita confirmación: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Escriba `yes` para confirmar la eliminación. + +## Estructura de proyecto recomendada + +Para proyectos más complejos, organice sus archivos así: + +``` +terraform-cloudtemple/ +├── main.tf # Recursos principales +├── versions.tf # Configuración del proveedor +├── variables.tf # Declaraciones de variables +├── outputs.tf # Declaraciones de outputs +├── terraform.tfvars # Valores de variables (no versionar) +├── .gitignore # Exclusiones Git +└── README.md # Documentación del proyecto +``` + +### Ejemplo de .gitignore + +```gitignore +# Archivos Terraform +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# Archivos de crash +crash.log +crash.*.log + +# Archivos de variables sensibles +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Comandos Terraform esenciales + +| Comando | Descripción | +|---------|-------------| +| `terraform init` | Inicializar el directorio de trabajo | +| `terraform validate` | Validar la sintaxis de configuración | +| `terraform fmt` | Formatear archivos automáticamente | +| `terraform plan` | Mostrar plan de ejecución | +| `terraform apply` | Aplicar cambios | +| `terraform destroy` | Destruir todos los recursos | +| `terraform show` | Mostrar estado actual | +| `terraform output` | Mostrar valores de outputs | +| `terraform state list` | Listar recursos gestionados | + +## Buenas prácticas + +### 1. Usar variables + +```hcl +# variables.tf +variable "environment" { + description = "Entorno de despliegue" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Organizar con módulos + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Usar un backend remoto + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Comentar su código + +```hcl +# Máquina virtual para servidor web de producción +# CPU y memoria dimensionados para gestionar 1000 req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Configuración hardware basada en benchmarks internos + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Usar datasources + +No recree lo que ya existe. Use datasources para referenciar recursos existentes: + +```hcl +# Referenciar una red existente +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Solución de problemas + +### Error: "Error: Failed to query available provider packages" + +**Causa**: Problema de conexión al Terraform Registry. + +**Solución**: Verifique su conexión a Internet y reintente `terraform init`. + +### Error: "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Causa**: Credenciales inválidas o caducadas. + +**Solución**: +1. Verifique sus variables de entorno +2. Genere una nueva clave API en la consola +3. Verifique los permisos de su clave API + +### Error: "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Causa**: El recurso referenciado (datacenter, clúster, etc.) no existe o no tiene acceso a él. + +**Solución**: +1. Verifique el nombre exacto (o uuid) en la consola Cloud Temple +2. Verifique sus derechos de acceso a este recurso + +## Próximos pasos + +Ahora que domina los fundamentos, explore tutoriales avanzados: + +- [Tutoriales IaaS VMware](tutorials.md#iaas-vmware): Despliegue avanzado de VMs, gestión de discos, configuración de red +- [Tutoriales IaaS OpenSource](tutorials.md#iaas-opensource): Máquinas virtuales XCP-ng, replicación, alta disponibilidad +- [Tutoriales Object Storage](tutorials.md#object-storage): Creación de buckets, gestión de ACL, integración S3 + +## Recursos adicionales + +- [Terraform Registry - Proveedor Cloud Temple](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Consola Cloud Temple](https://shiva.cloud-temple.com) +- [Conceptos Terraform Cloud Temple](concepts.md) diff --git a/i18n/es/docusaurus-plugin-content-docs/current/terraform/terraform.md b/i18n/es/docusaurus-plugin-content-docs/current/terraform/terraform.md new file mode 100644 index 00000000..ca0de121 --- /dev/null +++ b/i18n/es/docusaurus-plugin-content-docs/current/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Descripción general +--- + +El proveedor de Terraform Cloud Temple le permite gestionar la infraestructura de su cuenta Cloud Temple utilizando el enfoque de Infraestructura como Código (IaC). Ofrece una integración completa con los servicios de infraestructura Cloud Temple, permitiéndole aprovisionar, configurar y gestionar sus recursos en la nube de manera declarativa y reproducible. + +## Características principales + +- **Infraestructura como Código**: Defina su infraestructura en archivos de configuración versionables +- **Gestión declarativa**: Describa el estado deseado de su infraestructura, Terraform se encarga del resto +- **Automatización completa**: Automatice el aprovisionamiento y la gestión de sus recursos +- **Reproducibilidad**: Implemente entornos idénticos de manera fiable +- **Gestión de dependencias**: Terraform gestiona automáticamente el orden de creación de recursos + +## Productos cubiertos + +El proveedor de Terraform Cloud Temple admite los siguientes servicios: + +### IaaS VMware + +Gestione sus máquinas virtuales VMware con todas las características avanzadas de virtualización: + +- **Máquinas virtuales**: Creación y configuración de máquinas virtuales +- **Discos virtuales**: Creación y configuración de discos virtuales +- **Adaptadores de red**: Gestión de adaptadores de red de máquinas virtuales +- **Controladores virtuales**: Gestión de controladores de disco y otros dispositivos +- **Cloud-Init**: Configuración automatizada al inicio +- **Copia de seguridad**: Integración con políticas de copia de seguridad de Cloud Temple + +### IaaS OpenSource + +Aprovisione y gestione máquinas virtuales en infraestructura OpenSource basada en XCP-ng: + +- **Máquinas virtuales**: Creación y gestión de máquinas virtuales +- **Discos virtuales**: Creación y configuración de discos virtuales +- **Adaptadores de red**: Creación y configuración de adaptadores de red de máquinas virtuales +- **Replicación**: Políticas de replicación de datos +- **Alta disponibilidad**: Configuración HA (disabled, restart, best-effort) +- **Cloud-Init**: Configuración automatizada compatible con NoCloud +- **Copia de seguridad**: Integración con políticas de copia de seguridad de Cloud Temple + +### Almacenamiento de objetos + +Gestione sus espacios de almacenamiento de objetos compatibles con S3: + +- **Buckets**: Creación y configuración de buckets +- **Cuentas de almacenamiento**: Gestión de identidades y credenciales S3 +- **ACL**: Control de acceso granular a buckets +- **Control de versiones**: Gestión de versiones de objetos + +## Requisitos previos + +Antes de usar el proveedor de Terraform Cloud Temple, asegúrese de tener: + +### Acceso a la consola Cloud Temple + +Debe tener acceso a la [Consola Cloud Temple](https://shiva.cloud-temple.com) con los derechos apropiados en el tenant en el que desea trabajar. + +### Clave API + +El proveedor requiere credenciales de API de Cloud Temple: + +- **Client ID**: Identificador de cliente para autenticación +- **Secret ID**: Secreto asociado con el Client ID + +Estas credenciales se pueden generar desde la Consola Cloud Temple siguiendo [este procedimiento](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +### Derechos y permisos + +Dependiendo de los recursos que desee gestionar, debe tener los roles apropiados: + +#### Para IaaS VMware + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` y `backup_iaas_spp_write` (para copia de seguridad) + +#### Para IaaS OpenSource + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` y `backup_iaas_opensource_write` (para copia de seguridad) + +#### Para almacenamiento de objetos + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Derechos comunes + +- `activity_read` +- `tag_read` y `tag_write` + +## Compatibilidad con Terraform + +El proveedor Cloud Temple es compatible con: + +- **Terraform**: Versión 1.0 y superiores +- **OpenTofu**: Compatible con versiones recientes + +## Registro y depuración + +Para habilitar el registro detallado del proveedor: + +```bash +# Registro nivel DEBUG +export TF_LOG=DEBUG +terraform apply + +# Registro en formato JSON +export TF_LOG=JSON +terraform apply + +# Guardar registros en un archivo +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Soporte y recursos + +- **Documentación oficial**: [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Código fuente**: [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues**: [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Próximos pasos + +- [Conceptos](concepts.md): Comprenda los conceptos clave del proveedor +- [Guía de inicio](quickstart.md): Cree su primera infraestructura +- [Tutoriales](tutorials.md): Ejemplos prácticos y casos de uso diff --git a/i18n/es/docusaurus-plugin-content-docs/current/terraform/tutorials.md b/i18n/es/docusaurus-plugin-content-docs/current/terraform/tutorials.md new file mode 100644 index 00000000..2a3a4c53 --- /dev/null +++ b/i18n/es/docusaurus-plugin-content-docs/current/terraform/tutorials.md @@ -0,0 +1,1306 @@ +--- +title: Tutorials +--- + +# Tutoriales de Terraform en Cloud Temple + +Esta página contiene tutoriales prácticos para usar el proveedor Terraform de Cloud Temple con diferentes servicios. + +## Tabla de Contenidos + +- [VMware IaaS](#vmware-iaas) +- [OpenSource IaaS](#opensource-iaas) +- [Almacenamiento de Objetos](#almacenamiento-de-objetos) + +## VMware IaaS + +### Crear una VM Vacía + +**Objetivo**: Crear una máquina virtual VMware básica sin sistema operativo. + +**Requisitos previos**: +- Acceso a un centro de datos de Cloud Temple +- Credenciales API configuradas +- Permisos requeridos: + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Código**: + +```hcl +# Recuperar los recursos necesarios +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Crear una VM vacía +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Configuración de hardware + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-add habilitado + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Ubicación + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Sistema operativo invitado + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Explicaciones**: +- `guest_operating_system_moref`: Define el tipo de SO para los controladores de VMware Tools +- La VM se crea sin disco ni red (se añaden por separado) +- Las opciones hot-add permiten añadir CPU/RAM en caliente + +--- + +### Crear una VM desde el Marketplace + +**Objetivo**: Desplegar una VM desde una imagen del Marketplace de Cloud Temple. + +**Código**: + +```hcl +# Recuperar un elemento del Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Desplegar desde el Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Origen del Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Configuración + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Explicaciones**: +- `marketplace_item_id`: Hace referencia a una imagen lista para usar +- `datastore_id`: Datastore específico requerido para el despliegue desde Marketplace +- La imagen ya incluye un sistema operativo configurado + +--- + +### Crear una VM desde la Content Library + +**Objetivo**: Desplegar una VM desde una plantilla de VMware Content Library. + +**Código**: + +```hcl +# Recuperar la Content Library +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Recuperar un elemento específico +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Desplegar desde Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Origen Content Library + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuración del disco del SO + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # Configuración del adaptador de red del SO + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Explicaciones**: +- Los bloques `os_disk` y `os_network_adapter` configuran los recursos de la plantilla +- Estos bloques solo pueden usarse en el momento de la creación (ver sección dedicada) + +--- + +### Configurar Cloud-Init en VMware + +**Objetivo**: Automatizar la configuración de la VM en el primer arranque con Cloud-Init. + +**Requisitos previos**: Usar una imagen compatible con Cloud-Init (por ejemplo, Ubuntu Cloud Image en formato OVF). + +**Archivos Cloud-Init**: + +Crear `cloud-init/user-data.yml`: + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Crear `cloud-init/network-config.yml`: + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Código Terraform**: + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Configuración Cloud-Init (datasource OVF de VMware) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Claves Cloud-Init soportadas (VMware)**: +- `user-data`: Configuración principal (base64) +- `network-config`: Configuración de red (base64) +- `public-keys`: Claves públicas SSH +- `hostname`: Nombre de host +- `password`: Contraseña (o "RANDOM") +- `instance-id`: Identificador único +- `seedfrom`: URL de origen de configuración + +:::warning Limitación + Cloud-Init solo se ejecuta en el primer arranque de la VM. +::: + +--- + +### Crear un disco virtual y adjuntarlo a una VM + +**Objetivo**: Añadir almacenamiento adicional a una máquina virtual existente. + +**Código**: + +```hcl +# Referenciar una VM existente +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Crear un disco virtual +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # Adjuntar a la VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Tamaño del disco + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Modo de disco + disk_mode = "persistent" + + # Tipo de aprovisionamiento + provisioning_type = "dynamic" +} +``` + +**Modos de disco disponibles**: +- `persistent`: Los cambios se guardan inmediata y permanentemente en el disco virtual. +- `independent_nonpersistent`: Los cambios realizados en el disco virtual se guardan en un registro de rehacer y se eliminan al apagar. +- `independent_persistent`: Los cambios se guardan inmediata y permanentemente en el disco virtual. No se ven afectados por las instantáneas. + +**Tipos de aprovisionamiento**: +- `dynamic`: Ahorra espacio de almacenamiento asignando dinámicamente el espacio según sea necesario. La creación es rápida. +- `staticImmediate`: Asigna todo el espacio del disco en la creación, pero los bloques se ponen a cero en la primera escritura. +- `staticDiffered`: Asigna y pone a cero todo el espacio del disco en la creación. + +--- + +### Crear una interfaz de red y adjuntarla a una VM + +**Objetivo**: Añadir una tarjeta de red a una máquina virtual. + +**Código**: + +```hcl +# Recuperar la red +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# Referenciar la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Crear un adaptador de red +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # VM de destino + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Red + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Tipo de adaptador + type = "VMXNET3" + + # Conectar automáticamente al encender + connect_on_power_on = true + + # Dirección MAC (opcional, se genera automáticamente si se omite) + # mac_address = "00:50:56:xx:xx:xx" +} +``` + +:::info Tipos de adaptadores de red soportados + Los tipos de adaptadores compatibles que se pueden usar dependen del SO utilizado en la Máquina Virtual y de la versión de VMware. +::: + +--- + +### Crear un controlador virtual y adjuntarlo a una VM + +**Objetivo**: Añadir un controlador de disco a una máquina virtual. + +**Código**: + +```hcl +# Referenciar la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Crear un controlador SCSI +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # VM de destino + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Tipo de controlador + type = "SCSI" +} +``` + +**Tipos de controladores**: +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## OpenSource IaaS + +### Crear una VM desde una plantilla + +**Objetivo**: Desplegar una máquina virtual desde una plantilla de catálogo. + +**Requisitos previos**: +- Acceso a la infraestructura OpenSource de Cloud Temple +- Permisos requeridos: + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Código**: + +```hcl +# Recuperar una plantilla +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Recuperar el host +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Recuperar el repositorio de almacenamiento +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Recuperar la red +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Recuperar la política de respaldo +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# Crear la VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Origen + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Configuración de hardware + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Opciones + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # Disco del SO (debe coincidir con la plantilla) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # Adaptador de red del SO + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Respaldo + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Orden de arranque + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Explicaciones**: +- `high_availability`: Opciones disponibles: `disabled`, `restart`, `best-effort` (Ver [documentación](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) sobre Alta Disponibilidad) +- `boot_firmware`: `bios` o `uefi` +- `secure_boot`: Solo con UEFI + +--- + +### Crear una VM desde el Marketplace + +**Objetivo**: Desplegar una VM desde el Marketplace de Cloud Temple en OpenSource IaaS. + +**Código**: + +```hcl +# Recuperar un elemento del Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Desplegar desde el Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Origen del Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Configurar Replicación + +**Objetivo**: Configurar una política de replicación para una VM. + +**Código**: + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Crear una política de replicación +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Asociar con una VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... configuración estándar ... + + # Asociar la política de replicación + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Explicaciones**: +- `interval`: Intervalo de replicación. Se puede especificar en `minutes` u `hours` +- `storage_repository_id`: Repositorio de almacenamiento al cual se replicarán los discos de la VM. Debe estar en una AZ diferente a la VM original + +--- + +### Configurar Respaldo + +**Objetivo**: Aplicar una política de respaldo a una VM. + +**Código**: + +```hcl +# Recuperar políticas de respaldo +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM con múltiples políticas de respaldo +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... configuración estándar ... + + # Se pueden aplicar múltiples políticas + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Respaldo obligatorio + En un entorno SecNumCloud, se debe definir al menos una política de respaldo para iniciar la VM. +::: + +--- + +### Configurar Alta Disponibilidad + +**Objetivo**: Configurar el comportamiento de HA de una máquina virtual. + +**Código**: + +```hcl +# VM con HA deshabilitado +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM con reinicio prioritario +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM con best-effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Modos de HA disponibles**: + +Ver documentación sobre [Alta Disponibilidad](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) en la infraestructura OpenSource + +| Modo | Descripción | Uso | +|------|-------------|-------| +| `disabled` | Sin HA | Entornos de desarrollo | +| `restart` | Reinicio de alta prioridad | Producción crítica | +| `best-effort` | Reinicio si hay recursos disponibles | Producción estándar | + +--- + +### Configurar Cloud-Init en OpenSource + +**Objetivo**: Automatizar la configuración con Cloud-Init (datasource NoCloud). + +**Requisitos previos**: Imagen compatible con Cloud-Init NoCloud. + +**Archivos Cloud-Init**: + +Crear `cloud-init/cloud-config.yml`: + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Crear `cloud-init/network-config.yml`: + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important Nota + Adapte la configuración de cloud-init a sus necesidades y a la versión de Cloud-Init instalada en su máquina. El formato y la sintaxis pueden cambiar según las versiones. +::: + +**Código Terraform**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Configuración Cloud-Init (datasource NoCloud) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Diferencia con VMware**: +- OpenSource usa el datasource **NoCloud** +- Claves soportadas: `cloud_config` y `network_config` +- No se usa `filebase64()`, use `file()` directamente + +--- + +### Comprender os_disk y os_network_adapter + +Los bloques `os_disk` y `os_network_adapter` son bloques especiales usables **solo durante la creación** de una máquina virtual desde: + +- Content Library +- Plantilla +- Marketplace de Cloud Temple +- Clon de una VM existente + +:::info Info + Se usan para referenciar discos virtuales y adaptadores de red desplegados por la plantilla para poder modificar sus parámetros posteriormente sin tener que importarlos manualmente. No crean un nuevo recurso de ninguna manera. +::: + +**Características importantes**: + +1. **Solo en creación**: Estos bloques solo pueden definirse durante el `terraform apply` inicial +2. **Alternativa**: Use el comando `terraform import` para importarlos manualmente + +--- + +### Usar os_disk + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configurar el disco del SO existente en la plantilla + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Redimensionar a 100 GB + disk_mode = "persistent" + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # Configuración del disco del SO + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... otras configuraciones +} +``` + +--- + +### Usar os_network_adapter + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configurar el adaptador de red de la plantilla + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Opcional + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Configuración del adaptador de red + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Opcional + tx_checksumming = true + attached = true + } + + # ... otras configuraciones +} +``` + +:::info Nota + Puede combinar ambos enfoques referenciando los discos y/o adaptadores de red de una VM y añadiendo otros a través de los recursos `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` y `cloudtemple_compute_iaas_vmware/opensource_network_adapter` +::: + +--- + +**Mejores prácticas**: +1. Use `os_disk` y `os_network_adapter` para la configuración inicial de la plantilla +2. Use recursos dedicados para añadir recursos adicionales + +--- + +## Almacenamiento de Objetos + +### Crear un bucket + +**Objetivo**: Crear un bucket de almacenamiento de objetos compatible con S3. + +**Requisitos previos**: Permiso `object-storage_write` + +**Código**: + +```hcl +# Bucket privado +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Bucket público +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket con acceso personalizado (lista blanca de IPs) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # Lista blanca de IP/CIDR + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket con versionado habilitado +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Outputs útiles +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Tipos de acceso**: +- `private`: Acceso restringido a direcciones IP del tenant +- `public`: Acceso público de lectura +- `custom`: Acceso limitado a IPs de lista blanca + +**Versionado**: +- `Enabled`: Habilita el versionado de objetos +- `Suspended`: Suspende el versionado (mantiene las versiones existentes) + +--- + +### Crear una cuenta de almacenamiento + +**Objetivo**: Crear una cuenta de almacenamiento con credenciales S3. + +**Código**: + +```hcl +# Crear una cuenta de almacenamiento +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Outputs para usar las credenciales +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Información sensible + Las credenciales se muestran solo una vez. Almacénelas de forma segura (por ejemplo, HashiCorp Vault, AWS Secrets Manager). +::: + +--- + +### Crear ACLs mediante recurso dedicado + +**Objetivo**: Gestionar los permisos de acceso al bucket con ACLs. + +**Código**: + +```hcl +# Recuperar roles disponibles +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Recuperar cuentas de almacenamiento existentes +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL para el equipo de desarrollo (solo lectura) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL para el equipo de operaciones (mantenedor) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Roles disponibles**: +- `read_write`: Lectura y escritura +- `write_only`: Solo escritura +- `read_only`: Solo lectura +- `maintainer`: Acceso completo + +--- + +### Configurar ACLs directamente en el bucket + +**Objetivo**: Definir ACLs al crear el bucket. + +**Código**: + +```hcl +# Recuperar recursos +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket con ACLs inline +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # Definición de ACL en el bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Diferencia con recursos ACL dedicados**: +- **Inline**: ACLs definidas directamente en el bucket (más simple para configuraciones estáticas) +- **Recurso dedicado**: ACLs gestionadas por separado (más flexible, permite modificaciones independientes) + +--- + +### Usar datasources + +**Objetivo**: Consultar metadatos del bucket y listar archivos. + +**Código**: + +```hcl +# Datasource para listar archivos del bucket +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Mostrar todos los archivos +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Filtrar un archivo específico +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Recuperar una cuenta de almacenamiento existente +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### Integración S3 con el proveedor AWS + +**Objetivo**: Usar el proveedor AWS para subir archivos al almacenamiento de objetos de Cloud Temple. + +**Código**: + +```hcl +# Crear cuenta y bucket +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# Configurar el proveedor AWS para S3 de Cloud Temple +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Usar credenciales de Cloud Temple + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Endpoint de Cloud Temple + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Configuración para omitir validación de AWS + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Subir un archivo +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Subir múltiples archivos +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Verificar archivos subidos +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Conclusión + +Esta documentación cubre los principales casos de uso del proveedor Terraform de Cloud Temple. Para ir más allá: + +- Consulte la [documentación oficial del proveedor](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Explore los [ejemplos en GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Use la [Consola de Cloud Temple](https://shiva.cloud-temple.com) para identificar los recursos disponibles + +:::info ¿Necesita ayuda? + Para cualquier pregunta o problema, consulte la [sección de Issues en GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) o contacte al soporte de Cloud Temple. +::: diff --git a/i18n/fr/docusaurus-plugin-content-docs/current/terraform/concepts.md b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/concepts.md new file mode 100644 index 00000000..bfe42906 --- /dev/null +++ b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/concepts.md @@ -0,0 +1,471 @@ +--- +title: Concepts +--- + +# Concepts de Terraform dans le provider Cloud Temple + +Cette page présente les concepts fondamentaux nécessaires pour comprendre et utiliser efficacement le provider Terraform Cloud Temple. + +## Infrastructure as Code (IaC) + +L'Infrastructure as Code est une approche qui consiste à gérer et provisionner l'infrastructure informatique à travers des fichiers de configuration lisibles par l'homme, plutôt que par une configuration manuelle ou des outils interactifs. + +### Avantages de l'IaC avec Terraform + +- **Versionnage** : L'infrastructure est définie dans des fichiers qui peuvent être versionnés (Git) +- **Collaboration** : Les équipes peuvent travailler ensemble sur la même infrastructure +- **Automatisation** : Réduction des erreurs humaines et gain de temps +- **Documentation** : Le code décrit explicitement l'infrastructure +- **Reproductibilité** : Déploiement d'environnements identiques en quelques minutes + +## Provider Terraform + +Un provider Terraform est un plugin qui permet à Terraform d'interagir avec une API spécifique. Le provider Cloud Temple agit comme une couche d'abstraction entre vos fichiers de configuration Terraform et les APIs Cloud Temple. + +### Déclaration du provider + +Le provider doit être déclaré dans un bloc `terraform` avec `required_providers` : + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Authentification + +Le provider s'authentifie auprès des APIs Cloud Temple en utilisant : + +1. **Client ID** : Identifiant unique de votre application +2. **Secret ID** : Clé secrète associée au Client ID + +Ces identifiants sont générés depuis la Console de Cloud Temple et permettent au provider d'effectuer des opérations en votre nom. + +:::info Bonnes pratiques + Stockez vos credentials dans des variables d'environnement ou un gestionnaire de secrets, jamais directement dans le code. +::: + +## Ressources + +Une ressource représente un composant d'infrastructure qui peut être créé, lu, mis à jour ou supprimé (opérations CRUD). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Types de ressources Cloud Temple + +#### IaaS VMware + +- `cloudtemple_compute_virtual_machine` : Machine virtuelle +- `cloudtemple_compute_virtual_disk` : Disque virtuel +- `cloudtemple_compute_network_adapter` : Interface réseau +- `cloudtemple_compute_virtual_controller` : Contrôleur de périphérique + +#### IaaS OpenSource + +- `cloudtemple_compute_iaas_opensource_virtual_machine` : Machine virtuelle +- `cloudtemple_compute_iaas_opensource_virtual_disk` : Disque +- `cloudtemple_compute_iaas_opensource_network_adapter` : Interface réseau +- `cloudtemple_compute_iaas_opensource_replication_policy` : Politique de réplication + +#### Object Storage + +- `cloudtemple_object_storage_bucket` : Bucket S3 +- `cloudtemple_object_storage_storage_account` : Compte de stockage +- `cloudtemple_object_storage_acl_entry` : ACL d'un bucket +- `cloudtemple_object_storage_global_access_key`: Clé d'accès global au namespace + +### Attributs et arguments + +Chaque ressource possède : + +- **Arguments** : Valeurs que vous configurez (inputs) +- **Attributs** : Valeurs retournées par la ressource (outputs) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Arguments (configuration) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Attributs (calculés automatiquement) + # id, moref, machine_manager_id, etc. +} + +# Référence à un attribut +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Les datasources permettent de récupérer des informations sur des ressources existantes sans les gérer. Elles sont en **lecture seule**. + +### Utilisation des datasources + +```hcl +# Récupération d'un datacenter existant +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Récupération d'un cluster +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Utilisation dans une ressource +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Datasources principales + +Vous pouvez retrouver la liste complète des datasources disponibles dans le provider Terraform Cloud Temple sur [documentation Terraform](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Infrastructure Compute + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Datacenter virtuel | +| `cloudtemple_compute_host_cluster` | Cluster d'hôtes | +| `cloudtemple_compute_datastore_cluster` | Cluster de datastores | +| `cloudtemple_compute_datastore` | Datastore individuel | +| `cloudtemple_compute_network` | Réseau (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates et Marketplace + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_compute_content_library` | Bibliothèque de contenu | +| `cloudtemple_compute_content_library_item` | Item d'une bibliothèque | +| `cloudtemple_marketplace_item` | Item de la Marketplace Cloud Temple | +| `cloudtemple_compute_iaas_opensource_template` | Template dans le catalogue du IaaS OpenSource | + +#### Backup + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | Politique SLA de backup VMware | +| `cloudtemple_backup_iaas_opensource_policy` | Politique de backup OpenSource | + +#### Object Storage + +| Datasource | Description | +|------------|-------------| +| `cloudtemple_object_storage_role` | Rôles disponibles pour les ACL | +| `cloudtemple_object_storage_bucket_files` | Fichiers dans un bucket | +| `cloudtemple_object_storage_storage_account` | Compte de stockage existant | + +## État Terraform (State) + +Le state Terraform est un fichier qui maintient la correspondance entre votre configuration et les ressources réelles dans le cloud. + +### Fichier terraform.tfstate + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Backend remote + +Pour un travail d'équipe, stockez le state dans un backend distant : + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + Le fichier `terraform.tfstate` contient des informations sensibles. Ne le commitez jamais dans Git et utilisez un backend sécurisé pour le stockage. +::: + +:::info + OpenTofu propose le chiffrement du state par défaut ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: +## Cycle de vie Terraform + +### 1. Initialisation (terraform init) + +Initialise le répertoire de travail et télécharge le provider Cloud Temple : + +```bash +terraform init +``` + +Cette commande : +- Télécharge le provider depuis le Terraform Registry +- Initialise le backend (si configuré) +- Crée le répertoire `.terraform/` + +### 2. Planification (terraform plan) + +Génère un plan d'exécution montrant les changements qui seront appliqués : + +```bash +terraform plan +``` + +Le plan indique : +- **Ressources à créer** (`+`) +- **Ressources à modifier** (`~`) +- **Ressources à détruire** (`-`) +- **Ressources à recréer** (`-/+`) + +### 3. Application (terraform apply) + +Applique les changements pour atteindre l'état désiré : + +```bash +terraform apply +``` + +Terraform : +1. Génère un plan +2. Demande confirmation (sauf avec `--auto-approve`) +3. Applique les changements +4. Met à jour le state + +### 4. Destruction (terraform destroy) + +Détruit toutes les ressources gérées : + +```bash +terraform destroy +``` + +:::danger Attention + Cette commande supprime définitivement toutes les ressources. Utilisez-la avec précaution. +::: +### 5. Autres commandes utiles + +```bash +# Afficher l'état actuel +terraform show + +# Lister les ressources +terraform state list + +# Vérifier la configuration +terraform validate + +# Formater les fichiers +terraform fmt + +# Afficher les outputs +terraform output +``` + +## Dépendances et ordre d'exécution + +Terraform analyse automatiquement les dépendances entre ressources. + +### Dépendances implicites + +Terraform détecte les références entre ressources : + +```hcl +# La datasource est évaluée en premier +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Puis la VM est créée (dépendance implicite via datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Enfin le disque est attaché (dépendance via virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Dépendances explicites + +Pour forcer un ordre spécifique, utilisez `depends_on` : + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variables et outputs + +### Variables d'entrée + +Rendent votre configuration réutilisable : + +```hcl +variable "vm_name" { + description = "Nom de la machine virtuelle" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Mémoire en GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Outputs + +Exposent des informations après l'application : + +```hcl +output "vm_id" { + description = "ID de la machine virtuelle" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "Managed Object Reference VMware" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Modules + +Les modules permettent de regrouper et réutiliser des configurations : + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Bonnes pratiques + +### Organisation des fichiers + +``` +. +├── main.tf # Ressources principales +├── variables.tf # Déclarations des variables +├── outputs.tf # Déclarations des outputs +├── versions.tf # Versions Terraform et providers +├── terraform.tfvars # Valeurs des variables (ne pas commiter) +└── modules/ # Modules réutilisables + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Gestion des secrets + +```hcl +# ❌ À éviter +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "secret-en-clair" +} + +# ✅ Recommandé +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Utilisation de tags + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Prochaines étapes + +- [Guide de démarrage](quickstart.md) : Créez votre première infrastructure avec Terraform +- [Tutoriels](tutorials.md) : Exemples pratiques pour chaque service diff --git a/i18n/fr/docusaurus-plugin-content-docs/current/terraform/quickstart.md b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/quickstart.md new file mode 100644 index 00000000..18b441e0 --- /dev/null +++ b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/quickstart.md @@ -0,0 +1,565 @@ +--- +title: Guide de démarrage +--- + +# Guide de démarrage rapide + +Ce guide vous accompagne pas à pas pour déployer votre première infrastructure Cloud Temple avec Terraform. + +## Prérequis + +Avant de commencer, assurez-vous de disposer de : + +- Un compte Cloud Temple actif +- Accès à la [Console Cloud Temple](https://shiva.cloud-temple.com) +- Clé API (Client ID et Secret ID) +- Terraform installé sur votre machine (version 1.0 ou supérieure) + +## Étape 1 : Installer Terraform + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Téléchargez l'exécutable depuis [terraform.io](https://www.terraform.io/downloads) ou utilisez Chocolatey : + +```powershell +choco install terraform +``` + +### Vérification de l'installation + +```bash +terraform version +``` + +Vous devriez voir une sortie similaire à : + +``` +Terraform v1.6.0 +``` + +## Étape 2 : Obtenir votre Clé API + +### Génération d'un Clé API dans la Console + +Ces credentials peuvent être générés depuis la Console Cloud Temple en suivant [cette procédure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +:::warning Sécurité + Conservez ces credentials en lieu sûr. Le Secret ID ne sera affiché qu'une seule fois. +::: +### Configuration des variables d'environnement + +Exportez vos credentials en variables d'environnement : + +**Linux/macOS :** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell) :** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Étape 3 : Créer votre projet Terraform + +### Créer le répertoire du projet + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Créer le fichier de configuration du provider + +Créez un fichier `versions.tf` : + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Les credentials sont automatiquement récupérés depuis les variables d'environnement + # CLOUDTEMPLE_CLIENT_ID et CLOUDTEMPLE_SECRET_ID +} +``` + +## Étape 4 : Initialiser Terraform + +Initialisez votre projet Terraform pour télécharger le provider : + +```bash +terraform init +``` + +Vous devriez voir : + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Étape 5 : Créer votre première ressource + +### Exemple simple : Machine virtuelle VMware + +Créez un fichier `main.tf` avec une configuration minimale : + +```hcl +# Récupération des ressources existantes nécessaires +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Adaptez avec le nom de votre vCenter +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Adaptez avec le nom de votre datacenter + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Adaptez avec le nom de votre cluster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Adaptez avec le nom de votre datastore cluster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Politique de sauvegarde +} + +# Création d'une machine virtuelle +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Configuration matérielle + memory = 4 * 1024 * 1024 * 1024 # 4 GB en bytes + cpu = 2 + num_cores_per_socket = 1 + + # Options de flexibilité + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Emplacement + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Système d'exploitation + guest_operating_system_moref = "ubuntu64Guest" + + # Politique de sauvegarde + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tags + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output pour afficher l'ID de la VM +output "vm_id" { + description = "ID de la machine virtuelle créée" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference de la VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Adaptation des noms + Les noms des datacenters, clusters et datastores doivent correspondre à ceux disponibles dans votre environnement Cloud Temple. Consultez la console pour identifier les ressources disponibles. +::: + +## Étape 6 : Planifier les changements + +Avant d'appliquer les changements, visualisez ce qui va être créé : + +```bash +terraform plan +``` + +Terraform affiche un plan détaillé : + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Étape 7 : Appliquer la configuration + +Déployez votre infrastructure : + +```bash +terraform apply +``` + +Terraform vous demande confirmation : + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Tapez `yes` et appuyez sur Entrée. + +Terraform crée les ressources : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success Félicitations ! + Vous venez de créer votre première machine virtuelle Cloud Temple avec Terraform ! +::: + +## Étape 8 : Vérifier la création + +### Dans la console Cloud Temple + +1. Connectez-vous à la [Console Cloud Temple](https://shiva.cloud-temple.com) +2. Naviguez vers **IaaS VMWare** > **Machines virtuelles** +3. Vous devriez voir votre Machine Virtuelle `terraform-vm-01` + +### Avec Terraform + +Affichez l'état actuel : + +```bash +terraform show +``` + +Listez les ressources gérées : + +```bash +terraform state list +``` + +Affichez les outputs : + +```bash +terraform output +``` + +## Étape 9 : Modifier votre infrastructure + +Modifiez le fichier `main.tf` pour augmenter la mémoire à 8 GB : + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB au lieu de 4 GB + cpu = 2 + # ... reste de la configuration +} +``` + +Planifiez et appliquez les changements : + +```bash +terraform plan +terraform apply +``` + +Terraform détecte la modification et met à jour la VM : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (autres attributs inchangés) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Étape 10 : Détruire les ressources + +Lorsque vous avez terminé vos tests, supprimez les ressources créées : + +```bash +terraform destroy +``` + +Terraform affiche ce qui va être supprimé et demande confirmation : + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Tapez `yes` pour confirmer la suppression. + +## Structure de projet recommandée + +Pour des projets plus complexes, organisez vos fichiers ainsi : + +``` +terraform-cloudtemple/ +├── main.tf # Ressources principales +├── versions.tf # Configuration du provider +├── variables.tf # Déclarations des variables +├── outputs.tf # Déclarations des outputs +├── terraform.tfvars # Valeurs des variables (ne pas versionner) +├── .gitignore # Exclusions Git +└── README.md # Documentation du projet +``` + +### Exemple de .gitignore + +```gitignore +# Fichiers Terraform +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# Fichiers de crash +crash.log +crash.*.log + +# Fichiers de variables sensibles +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Commandes Terraform essentielles + +| Commande | Description | +|----------|-------------| +| `terraform init` | Initialise le répertoire de travail | +| `terraform validate` | Valide la syntaxe de la configuration | +| `terraform fmt` | Formate automatiquement les fichiers | +| `terraform plan` | Affiche le plan d'exécution | +| `terraform apply` | Applique les changements | +| `terraform destroy` | Détruit toutes les ressources | +| `terraform show` | Affiche l'état actuel | +| `terraform output` | Affiche les valeurs des outputs | +| `terraform state list` | Liste les ressources gérées | + +## Bonnes pratiques + +### 1. Utilisez des variables + +```hcl +# variables.tf +variable "environment" { + description = "Environnement de déploiement" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Organisez avec des modules + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Utilisez un backend distant + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Commentez votre code + +```hcl +# Machine virtuelle pour le serveur web de production +# CPU et mémoire dimensionnés pour gérer 1000 req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Configuration matérielle basée sur les benchmarks internes + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Utilisez des datasources + +Ne recréez pas ce qui existe déjà. Utilisez des datasources pour référencer les ressources existantes : + +```hcl +# Référencer un réseau existant +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Dépannage + +### Erreur : "Error: Failed to query available provider packages" + +**Cause** : Problème de connexion au Terraform Registry. + +**Solution** : Vérifiez votre connexion Internet et réessayez `terraform init`. + +### Erreur : "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Cause** : Credentials invalides ou expirés. + +**Solution** : +1. Vérifiez vos variables d'environnement +2. Générez une nouvelle clé API dans la console +3. Vérifiez les permissions de votre Clé API + +### Erreur : "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Cause** : La ressource référencée (datacenter, cluster, etc.) n'existe pas ou vous n'y avez pas accès. + +**Solution** : +1. Vérifiez le nom exact (ou l'uuid) dans la console Cloud Temple +2. Vérifiez vos droits d'accès sur cette ressource + +## Prochaines étapes + +Maintenant que vous maîtrisez les bases, explorez les tutoriels avancés : + +- [Tutoriels IaaS VMware](tutorials.md#iaas-vmware) : Déploiement avancé de VMs, gestion des disques, configuration réseau +- [Tutoriels IaaS OpenSource](tutorials.md#iaas-opensource) : Machines virtuelles XCP-ng, réplication, haute disponibilité +- [Tutoriels Object Storage](tutorials.md#object-storage) : Création de buckets, gestion des ACL, intégration S3 + +## Ressources complémentaires + +- [Terraform Registry - Provider Cloud Temple](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Console Cloud Temple](https://shiva.cloud-temple.com) +- [Concepts Terraform Cloud Temple](concepts.md) diff --git a/i18n/fr/docusaurus-plugin-content-docs/current/terraform/terraform.md b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/terraform.md new file mode 100644 index 00000000..d1b3bd15 --- /dev/null +++ b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Vue d'ensemble +--- + +Le provider Terraform Cloud Temple vous permet de gérer l'infrastructure de votre compte Cloud Temple en utilisant l'approche Infrastructure as Code (IaC). Il offre une intégration complète avec les services d'infrastructure Cloud Temple, permettant de provisionner, configurer et gérer vos ressources cloud de manière déclarative et reproductible. + +## Fonctionnalités principales + +- **Infrastructure as Code** : Définissez votre infrastructure dans des fichiers de configuration versionnables +- **Gestion déclarative** : Décrivez l'état souhaité de votre infrastructure, Terraform s'occupe du reste +- **Automatisation complète** : Automatisez le provisionnement et la gestion de vos ressources +- **Reproducibilité** : Déployez des environnements identiques de manière fiable +- **Gestion des dépendances** : Terraform gère automatiquement l'ordre de création des ressources + +## Produits couverts + +Le provider Terraform Cloud Temple prend en charge les services suivants : + +### IaaS VMware + +Gérez vos machines virtuelles VMware avec toutes les fonctionnalités avancées de virtualisation : + +- **Machines virtuelles** : Création et configuration de machines virtuelles +- **Disques virtuels** : Création et configuration des disques virtuels +- **Adaptateurs réseau** : Gestion des adapteurs réseau des machines virtuelles +- **Contrôleurs virtuels** : Gestion des contrôleurs de disques et autres périphériques +- **Cloud-Init** : Configuration automatisée au démarrage +- **Sauvegarde** : Intégration avec les politiques de sauvegarde Cloud Temple + +### IaaS OpenSource + +Provisionnez et gérez des machines virtuelles sur l'infrastructure OpenSource basée sur XCP-ng : + +- **Machines virtuelles** : Création et gestion de machines virtuelles +- **Disques virtuels** : Création et configuration des disques virtuels +- **Adaptateurs réseau** : Création et configuration des adapteurs réseau des machines virtuelles +- **Réplication** : Politiques de réplication des données +- **Haute disponibilité** : Configuration HA (disabled, restart, best-effort) +- **Cloud-Init** : Configuration automatisée compatible NoCloud +- **Sauvegarde** : Intégration avec les politiques de sauvegarde Cloud Temple + +### Stockage Objet + +Gérez vos espaces de stockage objet S3-compatible : + +- **Buckets** : Création et configuration de buckets +- **Comptes de stockage** : Gestion des identités et credentials S3 +- **ACL** : Contrôle d'accès granulaire aux buckets +- **Versioning** : Gestion des versions d'objets + +## Conditions préalables + +Avant d'utiliser le provider Terraform Cloud Temple, assurez-vous de disposer de : + +### Accès à la Console Cloud Temple + +Vous devez avoir accès à la [Console Cloud Temple](https://shiva.cloud-temple.com) avec les droits appropriés sur le tenant sur lequel vous souhaitez travailler. + +### Clé API + +Le provider nécessite des identifiants API Cloud Temple : + +- **Client ID** : Identifiant client pour l'authentification +- **Secret ID** : Secret associé au client ID + +Ces credentials peuvent être générés depuis la Console Cloud Temple en suivant [cette procédure](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +### Droits et permissions + +Selon les ressources que vous souhaitez gérer, vous devez disposer des rôles appropriés : + +#### Pour IaaS VMware + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` et `backup_iaas_spp_write` (pour la sauvegarde) + +#### Pour IaaS OpenSource + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` et `backup_iaas_opensource_write` (pour la sauvegarde) + +#### Pour Object Storage + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Droits communs + +- `activity_read` +- `tag_read` et `tag_write` + +## Compatibilité Terraform + +Le provider Cloud Temple est compatible avec : + +- **Terraform** : Version 1.0 et supérieures +- **OpenTofu** : Compatible avec les versions récentes + +## Logging et débogage + +Pour activer le logging détaillé du provider : + +```bash +# Logging niveau DEBUG +export TF_LOG=DEBUG +terraform apply + +# Logging au format JSON +export TF_LOG=JSON +terraform apply + +# Enregistrer les logs dans un fichier +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Support et ressources + +- **Documentation officielle** : [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Code source** : [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues** : [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Prochaines étapes + +- [Concepts](concepts.md) : Comprendre les concepts clés du provider +- [Guide de démarrage](quickstart.md) : Créer votre première infrastructure +- [Tutoriels](tutorials.md) : Exemples pratiques et cas d'usage diff --git a/i18n/fr/docusaurus-plugin-content-docs/current/terraform/tutorials.md b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/tutorials.md new file mode 100644 index 00000000..ab12fd17 --- /dev/null +++ b/i18n/fr/docusaurus-plugin-content-docs/current/terraform/tutorials.md @@ -0,0 +1,1303 @@ +--- +title: Tutoriels +--- + +# Tutoriels Terraform Cloud Temple + +Cette page regroupe des tutoriels pratiques pour utiliser le provider Terraform Cloud Temple avec différents services. + +## Sommaire + +- [IaaS VMware](#iaas-vmware) +- [IaaS OpenSource](#iaas-opensource) +- [Stockage Objet](#stockage-objet) + +## IaaS VMware + +### Créer une VM vide + +**Objectif** : Créer une machine virtuelle VMware de base sans système d'exploitation. + +**Prérequis** : +- Accès à un datacenter Cloud Temple +- Credentials API configurés +- Droits nécessaires + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code** : + +```hcl +# Récupération des ressources nécessaires +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Création d'une VM vide +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Configuration matérielle + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-add activé + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Emplacement + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Système d'exploitation guest + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Explications** : +- `guest_operating_system_moref` : Définit le type d'OS pour les pilotes VMware Tools +- La VM est créée sans disque ni réseau (à ajouter séparément) +- Les options hot-add permettent d'ajouter CPU/RAM à chaud + +--- + +### Créer une VM depuis la Marketplace + +**Objectif** : Déployer une VM à partir d'une image de la Marketplace Cloud Temple. + +**Code** : + +```hcl +# Récupération d'un item de la Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Déploiement depuis la Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Source Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Configuration + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Explications** : +- `marketplace_item_id` : Référence une image prête à l'emploi +- `datastore_id` : Datastore spécifique requis pour le déploiement Marketplace +- L'image inclut déjà un système d'exploitation configuré + +--- + +### Créer une VM depuis Content Library + +**Objectif** : Déployer une VM à partir d'un template de la Content Library VMware. + +**Code** : + +```hcl +# Récupération de la Content Library +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Récupération d'un item spécifique +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Déploiement depuis Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Source Content Library + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration du disque OS + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # Configuration de l'adaptateur réseau OS + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Explications** : +- Les blocs `os_disk` et `os_network_adapter` configurent les ressources du template +- Ces blocs ne peuvent être utilisés qu'à la création (voir section dédiée) + +--- + +### Configurer Cloud-Init VMware + +**Objectif** : Automatiser la configuration d'une VM au premier démarrage avec Cloud-Init. + +**Prérequis** : Utiliser une image compatible Cloud-Init (ex: Ubuntu Cloud Image en OVF). + +**Fichiers Cloud-Init** : + +Créez `cloud-init/user-data.yml` : + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Créez `cloud-init/network-config.yml` : + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Code Terraform** : + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Configuration Cloud-Init (VMware OVF datasource) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Clés Cloud-Init supportées (VMware)** : +- `user-data` : Configuration principale (base64) +- `network-config` : Configuration réseau (base64) +- `public-keys` : Clés SSH publiques +- `hostname` : Nom d'hôte +- `password` : Mot de passe (ou "RANDOM") +- `instance-id` : Identifiant unique +- `seedfrom` : URL source de configuration + +:::warning Limitation + Cloud-Init n'est exécuté qu'au premier démarrage de la VM. +::: +--- + +### Créer un disque virtuel et l'attacher à une VM + +**Objectif** : Ajouter du stockage supplémentaire à une machine virtuelle existante. + +**Code** : + +```hcl +# Référence à une VM existante +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Création d'un disque virtuel +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # Attachement à la VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Taille du disque + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Mode du disque + disk_mode = "persistent" + + # Type de provisionnement + provisioning_type = "dynamic" +} +``` + +**Modes de disque disponibles** : +- `persistent` : Les modifications sont immédiatement et définitivement enregistrées sur le disque virtuel. +- `independent_nonpersistent` : Les modifications apportées au disque virtuel sont enregistrées dans un journal de reprise et supprimées à la mise hors tension. +- `independent_persistent` : Les modifications sont immédiatement et définitivement enregistrées sur le disque virtuel. Non affecté par les snapshots. + +**Types de provisionnement** : +- `dynamic` : Économise de l'espace de stockage en allouant de l'espace de manière dynamique selon les besoins. La création est rapide. +- `staticImmediate` : Alloue tout l'espace disque lors de la création, mais les blocs sont remis à zéro lors de la première écriture. +- `staticDiffered` : Alloue et remet à zéro tout l'espace disque lors de la création. + +--- + +### Créer une interface réseau et l'attacher à une VM + +**Objectif** : Ajouter une carte réseau à une machine virtuelle. + +**Code** : + +```hcl +# Récupération du réseau +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# Référence à la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Création d'un adaptateur réseau +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # VM cible + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Réseau + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Type d'adaptateur + type = "VMXNET3" + + # Connexion automatique au démarrage + connect_on_power_on = true + + # MAC address (optionnel, générée automatiquement si omis) + # mac_address = "00:50:56:xx:xx:xx" +} +``` +:::info Type d'adaptateur réseaux supportés + Les types d'adaptateurs compatible pouvant être utilisés dépendent de l'OS utilisé sur la Machine Virtuelle ainsi que de la version de VMWare. +::: + +--- + +### Créer un contrôleur virtuel et l'attacher à une VM + +**Objectif** : Ajouter un contrôleur de disque à une machine virtuelle. + +**Code** : + +```hcl +# Référence à la VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Création d'un contrôleur SCSI +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # VM cible + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Type de contrôleur + type = "SCSI" +} +``` + +**Types de contrôleurs** : +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## IaaS OpenSource + +### Créer une VM depuis un template + +**Objectif** : Déployer une machine virtuelle à partir d'un template du catalogue. + +**Prérequis** : +- Accès à l'infrastructure OpenSource Cloud Temple +- Droits nécessaires : + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Code** : + +```hcl +# Récupération d'un template +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Récupération de l'hôte +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Récupération du storage repository +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Récupération du réseau +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Récupération de la politique de backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# Création de la VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Source + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Configuration matérielle + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Options + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # Disque OS (doit correspondre au template) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # Adaptateur réseau OS + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Backup + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Ordre de boot + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Explications** : +- `high_availability` : Options disponibles: `disabled`, `restart`, `best-effort` (Voir [documentation](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) sur la Haute Disponibilité) +- `boot_firmware` : `bios` ou `uefi` +- `secure_boot` : Uniquement avec UEFI + +--- + +### Créer une VM depuis la Marketplace + +**Objectif** : Déployer une VM depuis la Marketplace Cloud Temple sur le IaaS OpenSource. + +**Code** : + +```hcl +# Récupération d'un item Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Déploiement depuis Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Source Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Configurer la Réplication + +**Objectif** : Mettre en place une politique de réplication pour une VM. + +**Code** : + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Création d'une politique de réplication +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Association à une VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... configuration standard ... + + # Association de la politique de réplication + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Explications** : +- `interval` : Intervalle de réplication. Peut être formulé en `minutes`ou `hours` +- `storage_repository_id` : Storage Repository vers lequel les disques de la VM vont être répliqué. Doit être sur une AZ différente de la VM d'origine + +--- + +### Configurer la Sauvegarde + +**Objectif** : Appliquer une politique de sauvegarde à une VM. + +**Code** : + +```hcl +# Récupération des politiques de backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM avec plusieurs politiques de backup +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... configuration standard ... + + # Plusieurs politiques peuvent être appliquées + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Backup obligatoire + Dans un environnement SecNumCloud, au moins une politique de backup doit être définie pour pouvoir démarrer la VM. +::: +--- + +### Configurer la Haute Disponibilité + +**Objectif** : Configurer le comportement HA d'une machine virtuelle. + +**Code** : + +```hcl +# VM avec HA désactivée +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM avec restart prioritaire +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM avec best-effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Modes HA disponibles** : + +Voir documentation sur la [Haute Disponibilité](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) dans l'infrastructure OpenSource + +| Mode | Description | Usage | +|------|-------------|-------| +| `disabled` | Pas de HA | Environnements de développement | +| `restart` | Redémarrage haute priorité | Production critique | +| `best-effort` | Redémarrage si ressources disponibles | Production standard | + +--- + +### Configurer Cloud-Init OpenSource + +**Objectif** : Automatiser la configuration avec Cloud-Init (NoCloud datasource). + +**Prérequis** : Image compatible Cloud-Init NoCloud. + +**Fichiers Cloud-Init** : + +Créez `cloud-init/cloud-config.yml` : + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Créez `cloud-init/network-config.yml` : + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important A noter + Adaptez la configuration cloud-init à vos besoin et à la version de Cloud-Init installée sur votre machine. Le format et la syntaxe peuvent évoluer en fonction des versions. +::: + +**Code Terraform** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Configuration Cloud-Init (NoCloud datasource) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Différence avec VMware** : +- OpenSource utilise la datasource **NoCloud** +- Clés supportées : `cloud_config` et `network_config` +- Pas de `filebase64()`, utiliser `file()` directement + +--- + + +### Comprendre os_disk et os_network_adapter + +Les blocs `os_disk` et `os_network_adapter` sont des blocs spéciaux utilisables **uniquement lors de la création** d'une machine virtuelle à partir de : + +- Content Library +- Template +- Marketplace Cloud Temple +- Clone d'une VM existante + +:::info info + Ils servent à réferencer les disques virtuels et adaptateurs réseaux déployé par le template afin de pouvoir en modifier les paramètres par la suite sans avoir à les importer manuellement. Ils ne créent en aucun cas une nouvelle ressource. +::: + +**Caractéristiques importantes** : + +1. **Création uniquement** : Ces blocs ne peuvent être définis que lors du `terraform apply` initial +3. **Alternative** : Utilisez la commande `terraform import` pour les importer manuellement + +--- + +### Utiliser os_disk + +**IaaS VMware** : + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration du disque OS existant dans le template + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Redimensionner à 100 GB + disk_mode = "persistent" + } +} +``` + +**IaaS OpenSource** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # Configuration du disque OS + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... autres configurations +} +``` + +--- + +### Utiliser os_network_adapter + +**IaaS VMware** : + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configuration de l'adaptateur réseau du template + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Optionnel + } +} +``` + +**IaaS OpenSource** : + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Configuration de l'adaptateur réseau + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Optionnel + tx_checksumming = true + attached = true + } + + # ... autres configurations +} +``` + +:::info A noter + Vous pouvez tout à fait combiner les deux approches en réferençant les disques et/ou adaptateurs réseaux d'une VM et en ajouter d'autres via les ressource `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` et `cloudtemple_compute_iaas_vmware/opensource_network_adapter` +::: + +--- + +**Bonnes pratiques** : +1. Utilisez `os_disk` et `os_network_adapter` pour la configuration initiale du template +2. Utilisez les ressources dédiées pour ajouter des ressources supplémentaires + +--- + +## Stockage Objet + +### Créer un bucket + +**Objectif** : Créer un bucket de stockage objet S3-compatible. + +**Prérequis** : Droits `object-storage_write` + +**Code** : + +```hcl +# Bucket privé +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Bucket public +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket avec accès personnalisé (whitelist IP) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # Liste blanche d'adresses IP/CIDR + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket avec versioning activé +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Outputs utiles +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Types d'accès** : +- `private` : Accès restreint aux adresses IP du tenant +- `public` : Accès public en lecture +- `custom` : Accès limité aux IPs de la whitelist + +**Versioning** : +- `Enabled` : Active le versioning des objets +- `Suspended` : Suspend le versioning (conserve les versions existantes) + +--- + +### Créer un compte de stockage + +**Objectif** : Créer un compte de stockage avec des credentials S3. + +**Code** : + +```hcl +# Création d'un compte de stockage +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Outputs pour utiliser les credentials +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Informations sensibles + Les credentials sont affichés une seule fois. Stockez-les de manière sécurisée (ex: HashiCorp Vault, AWS Secrets Manager). +::: +--- + +### Créer des ACL via ressource dédiée + +**Objectif** : Gérer les permissions d'accès aux buckets avec des ACL. + +**Code** : + +```hcl +# Récupération des rôles disponibles +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Récupération de comptes de stockage existants +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL pour l'équipe dev (lecture seule) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL pour l'équipe ops (maintainer) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Rôles disponibles** : +- `read_write` : Lecture et écriture +- `write_only`: Écriture seule +- `read_only` : Lecture seule +- `maintainer` : Accès total + +--- + +### Configurer des ACL directement dans le bucket + +**Objectif** : Définir les ACL lors de la création du bucket. + +**Code** : + +```hcl +# Récupération des ressources +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket avec ACL intégrées +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # Définition des ACL dans le bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Différence avec les ressources ACL dédiées** : +- **Inline** : ACL définies directement dans le bucket (plus simple pour des configurations statiques) +- **Ressource dédiée** : ACL gérées séparément (plus flexible, permet des modifications indépendantes) + +--- + +### Utiliser les datasources + +**Objectif** : Interroger les métadonnées des buckets et lister les fichiers. + +**Code** : + +```hcl +# Datasource pour lister les fichiers d'un bucket +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Afficher tous les fichiers +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Filtrer un fichier spécifique +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Récupération d'un compte de stockage existant +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### Intégration S3 avec le provider AWS + +**Objectif** : Utiliser le provider AWS pour uploader des fichiers vers le stockage objet Cloud Temple. + +**Code** : + +```hcl +# Création du compte et du bucket +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# Configuration du provider AWS pour Cloud Temple S3 +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Utilisation des credentials Cloud Temple + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Endpoint Cloud Temple + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Configuration pour éviter la validation AWS + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Upload d'un fichier +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Upload de plusieurs fichiers +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Vérification des fichiers uploadés +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Conclusion + +Cette documentation couvre les principaux cas d'usage du provider Terraform Cloud Temple. Pour aller plus loin : + +- Consultez la [documentation officielle du provider](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Explorez les [exemples sur GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Utilisez la [Console Cloud Temple](https://shiva.cloud-temple.com) pour identifier les ressources disponibles + +:::info Besoin d'aide ? + Pour toute question ou problème, consultez la [section Issues sur GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) ou contactez le support Cloud Temple. +::: diff --git a/i18n/it/docusaurus-plugin-content-docs/current/terraform/concepts.md b/i18n/it/docusaurus-plugin-content-docs/current/terraform/concepts.md new file mode 100644 index 00000000..77c0ceb8 --- /dev/null +++ b/i18n/it/docusaurus-plugin-content-docs/current/terraform/concepts.md @@ -0,0 +1,473 @@ +--- +title: Concetti +--- + +# Concetti di Terraform nel provider Cloud Temple + +Questa pagina presenta i concetti fondamentali necessari per comprendere e utilizzare efficacemente il provider Terraform Cloud Temple. + +## Infrastructure as Code (IaC) + +L'Infrastructure as Code è un approccio che consiste nel gestire e provisionare l'infrastruttura informatica attraverso file di configurazione leggibili dall'uomo, piuttosto che tramite configurazione manuale o strumenti interattivi. + +### Vantaggi di IaC con Terraform + +- **Versionamento**: L'infrastruttura è definita in file che possono essere versionati (Git) +- **Collaborazione**: I team possono lavorare insieme sulla stessa infrastruttura +- **Automazione**: Riduzione degli errori umani e risparmio di tempo +- **Documentazione**: Il codice descrive esplicitamente l'infrastruttura +- **Riproducibilità**: Distribuzione di ambienti identici in pochi minuti + +## Provider Terraform + +Un provider Terraform è un plugin che permette a Terraform di interagire con un'API specifica. Il provider Cloud Temple agisce come uno strato di astrazione tra i file di configurazione Terraform e le API Cloud Temple. + +### Dichiarazione del provider + +Il provider deve essere dichiarato in un blocco `terraform` con `required_providers`: + +```hcl +terraform { + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Autenticazione + +Il provider si autentica presso le API Cloud Temple utilizzando: + +1. **Client ID**: Identificatore univoco della propria applicazione +2. **Secret ID**: Chiave segreta associata al Client ID + +Queste credenziali vengono generate dalla Console Cloud Temple e consentono al provider di eseguire operazioni per conto dell'utente. + +:::info Best Practice + Memorizzare le credenziali in variabili d'ambiente o in un gestore di segreti, mai direttamente nel codice. +::: + +## Risorse + +Una risorsa rappresenta un componente dell'infrastruttura che può essere creato, letto, aggiornato o eliminato (operazioni CRUD). + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + guest_operating_system_moref = "ubuntu64Guest" +} +``` + +### Tipi di risorse Cloud Temple + +#### IaaS VMware + +- `cloudtemple_compute_virtual_machine`: Macchina virtuale +- `cloudtemple_compute_virtual_disk`: Disco virtuale +- `cloudtemple_compute_network_adapter`: Interfaccia di rete +- `cloudtemple_compute_virtual_controller`: Controller di dispositivo + +#### IaaS OpenSource + +- `cloudtemple_compute_iaas_opensource_virtual_machine`: Macchina virtuale +- `cloudtemple_compute_iaas_opensource_virtual_disk`: Disco +- `cloudtemple_compute_iaas_opensource_network_adapter`: Interfaccia di rete +- `cloudtemple_compute_iaas_opensource_replication_policy`: Politica di replica + +#### Object Storage + +- `cloudtemple_object_storage_bucket`: Bucket S3 +- `cloudtemple_object_storage_storage_account`: Account di archiviazione +- `cloudtemple_object_storage_acl_entry`: ACL di un bucket +- `cloudtemple_object_storage_global_access_key`: Chiave di accesso globale al namespace + +### Attributi e argomenti + +Ogni risorsa ha: + +- **Argomenti**: Valori che si configurano (input) +- **Attributi**: Valori restituiti dalla risorsa (output) + +```hcl +resource "cloudtemple_compute_virtual_machine" "example" { + # Argomenti (configurazione) + name = "my-vm" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + + # Attributi (calcolati automaticamente) + # id, moref, machine_manager_id, etc. +} + +# Riferimento a un attributo +output "vm_id" { + value = cloudtemple_compute_virtual_machine.example.id +} +``` + +## Datasources + +Le datasources consentono di recuperare informazioni su risorse esistenti senza gestirle. Sono in **sola lettura**. + +### Utilizzo delle datasources + +```hcl +# Recupero di un datacenter esistente +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Recupero di un cluster +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu002-ucs01" +} + +# Utilizzo in una risorsa +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + # ... +} +``` + +### Datasources principali + +È possibile trovare l'elenco completo delle datasources disponibili nel provider Terraform Cloud Temple sulla [documentazione Terraform](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) + +#### Infrastruttura Compute + +| Datasource | Descrizione | +|------------|-------------| +| `cloudtemple_compute_virtual_datacenter` | Datacenter virtuale | +| `cloudtemple_compute_host_cluster` | Cluster di host | +| `cloudtemple_compute_datastore_cluster` | Cluster di datastore | +| `cloudtemple_compute_datastore` | Datastore individuale | +| `cloudtemple_compute_network` | Rete (VLAN, VXLAN) | +| `cloudtemple_compute_machine_manager` | Machine Manager (vCenter) | + +#### Templates e Marketplace + +| Datasource | Descrizione | +|------------|-------------| +| `cloudtemple_compute_content_library` | Libreria di contenuti | +| `cloudtemple_compute_content_library_item` | Elemento di libreria | +| `cloudtemple_marketplace_item` | Elemento Marketplace Cloud Temple | +| `cloudtemple_compute_iaas_opensource_template` | Template nel catalogo IaaS OpenSource | + +#### Backup + +| Datasource | Descrizione | +|------------|-------------| +| `cloudtemple_backup_sla_policy` | Politica SLA di backup VMware | +| `cloudtemple_backup_iaas_opensource_policy` | Politica di backup OpenSource | + +#### Object Storage + +| Datasource | Descrizione | +|------------|-------------| +| `cloudtemple_object_storage_role` | Ruoli disponibili per gli ACL | +| `cloudtemple_object_storage_bucket_files` | File in un bucket | +| `cloudtemple_object_storage_storage_account` | Account di archiviazione esistente | + +## Stato Terraform (State) + +Lo state Terraform è un file che mantiene la corrispondenza tra la configurazione e le risorse reali nel cloud. + +### File terraform.tfstate + +```json +{ + "version": 4, + "terraform_version": "1.5.0", + "resources": [ + { + "mode": "managed", + "type": "cloudtemple_compute_virtual_machine", + "name": "web", + "provider": "provider[\"registry.terraform.io/Cloud-Temple/cloudtemple\"]", + "instances": [...] + } + ] +} +``` + +### Backend remoto + +Per il lavoro di squadra, archiviare lo state in un backend remoto: + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +:::warning + Il file `terraform.tfstate` contiene informazioni sensibili. Non commitarlo mai in Git e utilizzare un backend sicuro per l'archiviazione. +::: + +:::info + OpenTofu offre la crittografia dello state per impostazione predefinita ([OpenTofu - State and Plan Encryption](https://opentofu.org/docs/language/state/encryption/)) +::: + +## Ciclo di vita Terraform + +### 1. Inizializzazione (terraform init) + +Inizializza la directory di lavoro e scarica il provider Cloud Temple: + +```bash +terraform init +``` + +Questo comando: +- Scarica il provider dal Terraform Registry +- Inizializza il backend (se configurato) +- Crea la directory `.terraform/` + +### 2. Pianificazione (terraform plan) + +Genera un piano di esecuzione mostrando le modifiche che verranno applicate: + +```bash +terraform plan +``` + +Il piano indica: +- **Risorse da creare** (`+`) +- **Risorse da modificare** (`~`) +- **Risorse da distruggere** (`-`) +- **Risorse da ricreare** (`-/+`) + +### 3. Applicazione (terraform apply) + +Applica le modifiche per raggiungere lo stato desiderato: + +```bash +terraform apply +``` + +Terraform: +1. Genera un piano +2. Richiede conferma (tranne con `--auto-approve`) +3. Applica le modifiche +4. Aggiorna lo state + +### 4. Distruzione (terraform destroy) + +Distrugge tutte le risorse gestite: + +```bash +terraform destroy +``` + +:::danger Attenzione + Questo comando elimina permanentemente tutte le risorse. Usare con cautela. +::: + +### 5. Altri comandi utili + +```bash +# Mostrare lo stato attuale +terraform show + +# Elencare le risorse +terraform state list + +# Verificare la configurazione +terraform validate + +# Formattare i file +terraform fmt + +# Mostrare gli output +terraform output +``` + +## Dipendenze e ordine di esecuzione + +Terraform analizza automaticamente le dipendenze tra le risorse. + +### Dipendenze implicite + +Terraform rileva i riferimenti tra le risorse: + +```hcl +# La datasource viene valutata per prima +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +# Poi viene creata la VM (dipendenza implicita tramite datacenter_id) +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + # ... +} + +# Infine viene collegato il disco (dipendenza tramite virtual_machine_id) +resource "cloudtemple_compute_virtual_disk" "data" { + name = "data-disk" + virtual_machine_id = cloudtemple_compute_virtual_machine.web.id + capacity = 100 * 1024 * 1024 * 1024 +} +``` + +### Dipendenze esplicite + +Per forzare un ordine specifico, utilizzare `depends_on`: + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + depends_on = [ + cloudtemple_compute_network_adapter.eth0 + ] +} +``` + +## Variabili e output + +### Variabili di input + +Rendono la configurazione riutilizzabile: + +```hcl +variable "vm_name" { + description = "Nome della macchina virtuale" + type = string + default = "my-vm" +} + +variable "vm_memory" { + description = "Memoria in GB" + type = number + default = 8 +} + +resource "cloudtemple_compute_virtual_machine" "example" { + name = var.vm_name + memory = var.vm_memory * 1024 * 1024 * 1024 + # ... +} +``` + +### Output + +Espongono informazioni dopo l'applicazione: + +```hcl +output "vm_id" { + description = "ID della macchina virtuale" + value = cloudtemple_compute_virtual_machine.example.id +} + +output "vm_moref" { + description = "Managed Object Reference VMware" + value = cloudtemple_compute_virtual_machine.example.moref +} +``` + +## Moduli + +I moduli consentono di raggruppare e riutilizzare le configurazioni: + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_server" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} + +module "db_server" { + source = "./modules/vm" + + name = "db-01" + memory = 16 * 1024 * 1024 * 1024 + cpu = 8 +} +``` + +## Best Practice + +### Organizzazione dei file + +``` +. +├── main.tf # Risorse principali +├── variables.tf # Dichiarazioni delle variabili +├── outputs.tf # Dichiarazioni degli output +├── versions.tf # Versioni Terraform e provider +├── terraform.tfvars # Valori delle variabili (non committare) +└── modules/ # Moduli riutilizzabili + └── vm/ + ├── main.tf + ├── variables.tf + └── outputs.tf +``` + +### Gestione dei segreti + +```hcl +# ❌ Da evitare +provider "cloudtemple" { + client_id = "12345678-1234-1234-1234-123456789abc" + secret_id = "segreto-in-chiaro" +} + +# ✅ Consigliato +provider "cloudtemple" { + client_id = var.cloudtemple_client_id + secret_id = var.cloudtemple_secret_id +} +``` + +### Utilizzo dei tag + +```hcl +resource "cloudtemple_compute_virtual_machine" "web" { + name = "web-server" + # ... + + tags = { + environment = "production" + managed_by = "terraform" + team = "platform" + cost_center = "engineering" + } +} +``` + +## Prossimi passi + +- [Guida introduttiva](quickstart.md): Creare la prima infrastruttura con Terraform +- [Tutorial](tutorials.md): Esempi pratici per ogni servizio diff --git a/i18n/it/docusaurus-plugin-content-docs/current/terraform/quickstart.md b/i18n/it/docusaurus-plugin-content-docs/current/terraform/quickstart.md new file mode 100644 index 00000000..08bcb868 --- /dev/null +++ b/i18n/it/docusaurus-plugin-content-docs/current/terraform/quickstart.md @@ -0,0 +1,566 @@ +--- +title: Guida introduttiva +--- + +# Guida rapida + +Questa guida vi accompagna passo dopo passo nella distribuzione della vostra prima infrastruttura Cloud Temple con Terraform. + +## Prerequisiti + +Prima di iniziare, assicuratevi di avere: + +- Un account Cloud Temple attivo +- Accesso alla [Console Cloud Temple](https://shiva.cloud-temple.com) +- Chiave API (Client ID e Secret ID) +- Terraform installato sulla vostra macchina (versione 1.0 o superiore) + +## Passo 1: Installare Terraform + +### Linux (Ubuntu/Debian) + +```bash +wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +### macOS + +```bash +brew tap hashicorp/tap +brew install hashicorp/tap/terraform +``` + +### Windows + +Scaricate l'eseguibile da [terraform.io](https://www.terraform.io/downloads) o utilizzate Chocolatey: + +```powershell +choco install terraform +``` + +### Verifica dell'installazione + +```bash +terraform version +``` + +Dovreste vedere un output simile a: + +``` +Terraform v1.6.0 +``` + +## Passo 2: Ottenere la chiave API + +### Generazione di una chiave API nella console + +Queste credenziali possono essere generate dalla Console Cloud Temple seguendo [questa procedura](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +:::warning Sicurezza + Conservate queste credenziali in modo sicuro. Il Secret ID verrà visualizzato una sola volta. +::: + +### Configurazione delle variabili d'ambiente + +Esportate le vostre credenziali come variabili d'ambiente: + +**Linux/macOS:** + +```bash +export CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +export CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +**Windows (PowerShell):** + +```powershell +$env:CLOUDTEMPLE_CLIENT_ID="12345678-1234-1234-1234-123456789abc" +$env:CLOUDTEMPLE_SECRET_ID="87654321-4321-4321-4321-cba987654321" +``` + +## Passo 3: Creare il progetto Terraform + +### Creare la directory del progetto + +```bash +mkdir terraform-cloudtemple-quickstart +cd terraform-cloudtemple-quickstart +``` + +### Creare il file di configurazione del provider + +Create un file `versions.tf`: + +```hcl +terraform { + required_version = ">= 1.0" + + required_providers { + cloudtemple = { + source = "Cloud-Temple/cloudtemple" + version = "~> 1.0" + } + } +} + +provider "cloudtemple" { + # Le credenziali vengono recuperate automaticamente dalle variabili d'ambiente + # CLOUDTEMPLE_CLIENT_ID e CLOUDTEMPLE_SECRET_ID +} +``` + +## Passo 4: Inizializzare Terraform + +Inizializzate il vostro progetto Terraform per scaricare il provider: + +```bash +terraform init +``` + +Dovreste vedere: + +``` +Initializing the backend... + +Initializing provider plugins... +- Finding Cloud-Temple/cloudtemple versions matching "~> 1.0"... +- Installing Cloud-Temple/cloudtemple v1.x.x... +- Installed Cloud-Temple/cloudtemple v1.x.x (signed by HashiCorp) + +Terraform has been successfully initialized! +``` + +## Passo 5: Creare la prima risorsa + +### Esempio semplice: Macchina virtuale VMware + +Create un file `main.tf` con una configurazione minima: + +```hcl +# Recupero delle risorse esistenti necessarie +data "cloudtemple_compute_machine_manager" "vc-vstack-01" { + name = "vc-vstack-001-t0001" # Adattate con il nome del vostro vCenter +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" # Adattate con il nome del vostro datacenter + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" # Adattate con il nome del vostro cluster + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" # Adattate con il nome del vostro cluster datastore + machine_manager_id = data.cloudtemple_compute_machine_manager.vc-vstack-01.id +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" # Politica di backup +} + +# Creazione di una macchina virtuale +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + # Configurazione hardware + memory = 4 * 1024 * 1024 * 1024 # 4 GB in byte + cpu = 2 + num_cores_per_socket = 1 + + # Opzioni di flessibilità + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Posizione + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Sistema operativo + guest_operating_system_moref = "ubuntu64Guest" + + # Politica di backup + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + # Tag + tags = { + environment = "demo" + managed_by = "terraform" + owner = "quickstart" + } +} + +# Output per visualizzare l'ID della VM +output "vm_id" { + description = "ID della macchina virtuale creata" + value = cloudtemple_compute_virtual_machine.my_first_vm.id +} + +output "vm_moref" { + description = "Managed Object Reference della VM" + value = cloudtemple_compute_virtual_machine.my_first_vm.moref +} +``` + +:::note Adattamento dei nomi + I nomi dei datacenter, cluster e datastore devono corrispondere a quelli disponibili nel vostro ambiente Cloud Temple. Consultate la console per identificare le risorse disponibili. +::: + +## Passo 6: Pianificare le modifiche + +Prima di applicare le modifiche, visualizzate cosa verrà creato: + +```bash +terraform plan +``` + +Terraform visualizza un piano dettagliato: + +``` +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be created + + resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + + cpu = 2 + + datacenter_id = "xxxx-xxxx-xxxx" + + guest_operating_system = "ubuntu64Guest" + + id = (known after apply) + + memory = 4294967296 + + name = "terraform-vm-01" + + moref = (known after apply) + ... + } + +Plan: 1 to add, 0 to change, 0 to destroy. +``` + +## Passo 7: Applicare la configurazione + +Distribuite la vostra infrastruttura: + +```bash +terraform apply +``` + +Terraform chiede conferma: + +``` +Do you want to perform these actions? + Terraform will perform the actions described above. + Only 'yes' will be accepted to approve. + + Enter a value: +``` + +Digitate `yes` e premete Invio. + +Terraform crea le risorse: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Creating... +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [10s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Still creating... [20s elapsed] +cloudtemple_compute_virtual_machine.my_first_vm: Creation complete after 25s [id=12345678-1234-1234-1234-123456789abc] + +Apply complete! Resources: 1 added, 0 changed, 0 destroyed. + +Outputs: + +vm_id = "12345678-1234-1234-1234-123456789abc" +vm_moref = "vm-123" +``` + +:::success Congratulazioni! + Avete appena creato la vostra prima macchina virtuale Cloud Temple con Terraform! +::: + +## Passo 8: Verificare la creazione + +### Nella console Cloud Temple + +1. Accedete alla [Console Cloud Temple](https://shiva.cloud-temple.com) +2. Navigate a **IaaS VMWare** > **Macchine virtuali** +3. Dovreste vedere la vostra Macchina Virtuale `terraform-vm-01` + +### Con Terraform + +Visualizzare lo stato attuale: + +```bash +terraform show +``` + +Elencare le risorse gestite: + +```bash +terraform state list +``` + +Visualizzare gli output: + +```bash +terraform output +``` + +## Passo 9: Modificare l'infrastruttura + +Modificate il file `main.tf` per aumentare la memoria a 8 GB: + +```hcl +resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + name = "terraform-vm-01" + + memory = 8 * 1024 * 1024 * 1024 # 8 GB invece di 4 GB + cpu = 2 + # ... resto della configurazione +} +``` + +Pianificate e applicate le modifiche: + +```bash +terraform plan +terraform apply +``` + +Terraform rileva la modifica e aggiorna la VM: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be updated in-place + ~ resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + ~ memory = 4294967296 -> 8589934592 + # (altri attributi invariati) + } + +Plan: 0 to add, 1 to change, 0 to destroy. +``` + +## Passo 10: Distruggere le risorse + +Quando avete terminato i test, eliminate le risorse create: + +```bash +terraform destroy +``` + +Terraform visualizza cosa verrà eliminato e chiede conferma: + +``` +cloudtemple_compute_virtual_machine.my_first_vm: Refreshing state... [id=xxx] + +Terraform will perform the following actions: + + # cloudtemple_compute_virtual_machine.my_first_vm will be destroyed + - resource "cloudtemple_compute_virtual_machine" "my_first_vm" { + - cpu = 2 + - memory = 8589934592 + - name = "terraform-vm-01" + ... + } + +Plan: 0 to add, 0 to change, 1 to destroy. + +Do you really want to destroy all resources? + Terraform will destroy all your managed infrastructure. + Only 'yes' will be accepted to confirm. + + Enter a value: +``` + +Digitate `yes` per confermare l'eliminazione. + +## Struttura di progetto consigliata + +Per progetti più complessi, organizzate i vostri file così: + +``` +terraform-cloudtemple/ +├── main.tf # Risorse principali +├── versions.tf # Configurazione del provider +├── variables.tf # Dichiarazioni delle variabili +├── outputs.tf # Dichiarazioni degli output +├── terraform.tfvars # Valori delle variabili (non versionare) +├── .gitignore # Esclusioni Git +└── README.md # Documentazione del progetto +``` + +### Esempio di .gitignore + +```gitignore +# File Terraform +.terraform/ +*.tfstate +*.tfstate.* +terraform.tfvars +.terraform.lock.hcl + +# File di crash +crash.log +crash.*.log + +# File di variabili sensibili +*.auto.tfvars +override.tf +override.tf.json +*_override.tf +*_override.tf.json +``` + +## Comandi Terraform essenziali + +| Comando | Descrizione | +|---------|-------------| +| `terraform init` | Inizializzare la directory di lavoro | +| `terraform validate` | Validare la sintassi della configurazione | +| `terraform fmt` | Formattare automaticamente i file | +| `terraform plan` | Visualizzare il piano di esecuzione | +| `terraform apply` | Applicare le modifiche | +| `terraform destroy` | Distruggere tutte le risorse | +| `terraform show` | Visualizzare lo stato attuale | +| `terraform output` | Visualizzare i valori degli output | +| `terraform state list` | Elencare le risorse gestite | + +## Best Practice + +### 1. Utilizzare le variabili + +```hcl +# variables.tf +variable "environment" { + description = "Ambiente di distribuzione" + type = string + default = "dev" +} + +# main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = "${var.environment}-vm-01" + # ... + + tags = { + environment = var.environment + } +} +``` + +### 2. Organizzare con i moduli + +```hcl +# modules/vm/main.tf +resource "cloudtemple_compute_virtual_machine" "vm" { + name = var.name + memory = var.memory + cpu = var.cpu + # ... +} + +# main.tf +module "web_vm" { + source = "./modules/vm" + + name = "web-01" + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 +} +``` + +### 3. Utilizzare un backend remoto + +```hcl +terraform { + backend "s3" { + bucket = "terraform-state-cloudtemple" + key = "prod/terraform.tfstate" + region = "eu-west-1" + } +} +``` + +### 4. Commentare il codice + +```hcl +# Macchina virtuale per server web di produzione +# CPU e memoria dimensionati per gestire 1000 req/s +resource "cloudtemple_compute_virtual_machine" "web_prod" { + name = "web-prod-01" + + # Configurazione hardware basata su benchmark interni + memory = 16 * 1024 * 1024 * 1024 # 16 GB + cpu = 8 + # ... +} +``` + +### 5. Utilizzare le datasources + +Non ricreate ciò che già esiste. Utilizzate le datasources per fare riferimento a risorse esistenti: + +```hcl +# Fare riferimento a una rete esistente +data "cloudtemple_compute_network" "prod_network" { + name = "PROD-VLAN-100" +} + +resource "cloudtemple_compute_network_adapter" "nic" { + network_id = data.cloudtemple_compute_network.prod_network.id + # ... +} +``` + +## Risoluzione dei problemi + +### Errore: "Error: Failed to query available provider packages" + +**Causa**: Problema di connessione al Terraform Registry. + +**Soluzione**: Verificate la vostra connessione Internet e riprovate `terraform init`. + +### Errore: "Error: failed to login" + +``` +Error: failed to login: Unexpected response code: 401 +``` + +**Causa**: Credenziali non valide o scadute. + +**Soluzione**: +1. Verificate le vostre variabili d'ambiente +2. Generate una nuova chiave API nella console +3. Verificate i permessi della vostra chiave API + +### Errore: "Error: resource not found" + +``` +Error: failed to find datastore named "ds002-t0001-r-stw1-data13-th3s" +``` + +**Causa**: La risorsa referenziata (datacenter, cluster, ecc.) non esiste o non avete accesso ad essa. + +**Soluzione**: +1. Verificate il nome esatto (o uuid) nella console Cloud Temple +2. Verificate i vostri diritti di accesso a questa risorsa + +## Prossimi passi + +Ora che padroneggiate le basi, esplorate i tutorial avanzati: + +- [Tutorial IaaS VMware](tutorials.md#iaas-vmware): Distribuzione avanzata di VM, gestione dei dischi, configurazione di rete +- [Tutorial IaaS OpenSource](tutorials.md#iaas-opensource): Macchine virtuali XCP-ng, replica, alta disponibilità +- [Tutorial Object Storage](tutorials.md#object-storage): Creazione di bucket, gestione ACL, integrazione S3 + +## Risorse aggiuntive + +- [Terraform Registry - Provider Cloud Temple](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple) +- [Console Cloud Temple](https://shiva.cloud-temple.com) +- [Concetti Terraform Cloud Temple](concepts.md) diff --git a/i18n/it/docusaurus-plugin-content-docs/current/terraform/terraform.md b/i18n/it/docusaurus-plugin-content-docs/current/terraform/terraform.md new file mode 100644 index 00000000..8179bb90 --- /dev/null +++ b/i18n/it/docusaurus-plugin-content-docs/current/terraform/terraform.md @@ -0,0 +1,134 @@ +--- +title: Panoramica +--- + +Il provider Terraform Cloud Temple consente di gestire l'infrastruttura del proprio account Cloud Temple utilizzando l'approccio Infrastructure as Code (IaC). Offre un'integrazione completa con i servizi di infrastruttura Cloud Temple, consentendo di provisioning, configurare e gestire le risorse cloud in modo dichiarativo e riproducibile. + +## Funzionalità principali + +- **Infrastructure as Code**: Definire l'infrastruttura in file di configurazione versionabili +- **Gestione dichiarativa**: Descrivere lo stato desiderato dell'infrastruttura, Terraform si occupa del resto +- **Automazione completa**: Automatizzare il provisioning e la gestione delle risorse +- **Riproducibilità**: Distribuire ambienti identici in modo affidabile +- **Gestione delle dipendenze**: Terraform gestisce automaticamente l'ordine di creazione delle risorse + +## Prodotti coperti + +Il provider Terraform Cloud Temple supporta i seguenti servizi: + +### IaaS VMware + +Gestire le macchine virtuali VMware con tutte le funzionalità avanzate di virtualizzazione: + +- **Macchine virtuali**: Creazione e configurazione di macchine virtuali +- **Dischi virtuali**: Creazione e configurazione di dischi virtuali +- **Adattatori di rete**: Gestione degli adattatori di rete delle macchine virtuali +- **Controller virtuali**: Gestione dei controller di disco e altri dispositivi +- **Cloud-Init**: Configurazione automatizzata all'avvio +- **Backup**: Integrazione con le politiche di backup di Cloud Temple + +### IaaS OpenSource + +Provisioning e gestione di macchine virtuali su infrastruttura OpenSource basata su XCP-ng: + +- **Macchine virtuali**: Creazione e gestione di macchine virtuali +- **Dischi virtuali**: Creazione e configurazione di dischi virtuali +- **Adattatori di rete**: Creazione e configurazione degli adattatori di rete delle macchine virtuali +- **Replica**: Politiche di replica dei dati +- **Alta disponibilità**: Configurazione HA (disabled, restart, best-effort) +- **Cloud-Init**: Configurazione automatizzata compatibile con NoCloud +- **Backup**: Integrazione con le politiche di backup di Cloud Temple + +### Object Storage + +Gestire gli spazi di archiviazione oggetti compatibili con S3: + +- **Bucket**: Creazione e configurazione di bucket +- **Account di archiviazione**: Gestione delle identità e delle credenziali S3 +- **ACL**: Controllo granulare degli accessi ai bucket +- **Versionamento**: Gestione delle versioni degli oggetti + +## Prerequisiti + +Prima di utilizzare il provider Terraform Cloud Temple, assicurarsi di disporre di: + +### Accesso alla console Cloud Temple + +È necessario avere accesso alla [Console Cloud Temple](https://shiva.cloud-temple.com) con i diritti appropriati sul tenant su cui si desidera lavorare. + +### Chiave API + +Il provider richiede le credenziali API di Cloud Temple: + +- **Client ID**: Identificatore client per l'autenticazione +- **Secret ID**: Segreto associato al Client ID + +Queste credenziali possono essere generate dalla Console Cloud Temple seguendo [questa procedura](https://docs.cloud-temple.com/console/api#cl%C3%A9s-api). + +### Diritti e permessi + +A seconda delle risorse che si desidera gestire, è necessario disporre dei ruoli appropriati: + +#### Per IaaS VMware + +- `compute_iaas_vmware_infrastructure_read` +- `compute_iaas_vmware_infrastructure_write` +- `compute_iaas_vmware_management` +- `compute_iaas_vmware_read` +- `compute_iaas_vmware_virtual_machine_power` +- `backup_iaas_spp_read` e `backup_iaas_spp_write` (per il backup) + +#### Per IaaS OpenSource + +- `compute_iaas_opensource_management` +- `compute_iaas_opensource_read` +- `compute_iaas_opensource_virtual_machine_power` +- `backup_iaas_opensource_read` e `backup_iaas_opensource_write` (per il backup) + +#### Per Object Storage + +- `object-storage_write` +- `object-storage_read` +- `object-storage_iam_management` + +#### Diritti comuni + +- `activity_read` +- `tag_read` e `tag_write` + +## Compatibilità Terraform + +Il provider Cloud Temple è compatibile con: + +- **Terraform**: Versione 1.0 e successive +- **OpenTofu**: Compatibile con le versioni recenti + +## Logging e debug + +Per abilitare il logging dettagliato del provider: + +```bash +# Logging livello DEBUG +export TF_LOG=DEBUG +terraform apply + +# Logging in formato JSON +export TF_LOG=JSON +terraform apply + +# Salvare i log in un file +export TF_LOG_PATH=./terraform.log +terraform apply +``` + +## Supporto e risorse + +- **Documentazione ufficiale**: [Terraform Registry](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- **Codice sorgente**: [GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple) +- **Issues**: [GitHub Issues](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) + +## Prossimi passi + +- [Concetti](concepts.md): Comprendere i concetti chiave del provider +- [Guida introduttiva](quickstart.md): Creare la prima infrastruttura +- [Tutorial](tutorials.md): Esempi pratici e casi d'uso diff --git a/i18n/it/docusaurus-plugin-content-docs/current/terraform/tutorials.md b/i18n/it/docusaurus-plugin-content-docs/current/terraform/tutorials.md new file mode 100644 index 00000000..197222fa --- /dev/null +++ b/i18n/it/docusaurus-plugin-content-docs/current/terraform/tutorials.md @@ -0,0 +1,1306 @@ +--- +title: Tutorials +--- + +# Tutorial Terraform di Cloud Temple + +Questa pagina contiene tutorial pratici per utilizzare il provider Terraform di Cloud Temple con diversi servizi. + +## Sommario + +- [VMware IaaS](#vmware-iaas) +- [OpenSource IaaS](#opensource-iaas) +- [Object Storage](#object-storage) + +## VMware IaaS + +### Creare una VM Vuota + +**Obiettivo**: Creare una macchina virtuale VMware di base senza sistema operativo. + +**Prerequisiti**: +- Accesso a un datacenter di Cloud Temple +- Credenziali API configurate +- Permessi richiesti: + - `compute_iaas_vmware_read` + - `compute_iaas_vmware_management` + - `compute_iaas_vmware_virtual_machine_power` + - `compute_iaas_vmware_infrastructure_read` + - `backup_iaas_vmware_read` + - `backup_iaas_vmware_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Codice**: + +```hcl +# Recuperare le risorse richieste +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "datastore" { + name = "sdrs001-LIVE" +} + +# Creare una VM vuota +resource "cloudtemple_compute_virtual_machine" "empty_vm" { + name = "vm-empty-01" + + # Configurazione hardware + memory = 4 * 1024 * 1024 * 1024 # 4 GB + cpu = 2 + num_cores_per_socket = 1 + + # Hot-add abilitato + cpu_hot_add_enabled = true + memory_hot_add_enabled = true + + # Posizione + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.datastore.id + + # Sistema operativo guest + guest_operating_system_moref = "ubuntu64Guest" + + tags = { + environment = "demo" + created_by = "terraform" + } +} +``` + +**Spiegazioni**: +- `guest_operating_system_moref`: Definisce il tipo di SO per i driver VMware Tools +- La VM viene creata senza disco o rete (da aggiungere separatamente) +- Le opzioni hot-add permettono di aggiungere CPU/RAM al volo + +--- + +### Creare una VM dal Marketplace + +**Obiettivo**: Distribuire una VM da un'immagine del Marketplace di Cloud Temple. + +**Codice**: + +```hcl +# Recuperare un elemento del Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_backup_sla_policy" "daily" { + name = "sla001-daily-par7s" +} + +# Distribuire dal Marketplace +resource "cloudtemple_compute_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + + # Origine Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + + # Configurazione + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + power_state = "on" + + backup_sla_policies = [ + data.cloudtemple_backup_sla_policy.daily.id + ] + + tags = { + source = "marketplace" + } +} +``` + +**Spiegazioni**: +- `marketplace_item_id`: Fa riferimento a un'immagine pronta all'uso +- `datastore_id`: Datastore specifico richiesto per la distribuzione dal Marketplace +- L'immagine include già un sistema operativo configurato + +--- + +### Creare una VM dalla Content Library + +**Obiettivo**: Distribuire una VM da un template della Content Library VMware. + +**Codice**: + +```hcl +# Recuperare la Content Library +data "cloudtemple_compute_content_library" "public" { + name = "PUBLIC" +} + +# Recuperare un elemento specifico +data "cloudtemple_compute_content_library_item" "centos" { + content_library_id = data.cloudtemple_compute_content_library.public.id + name = "centos-8-template" +} + +data "cloudtemple_compute_virtual_datacenter" "dc" { + name = "DC-EQX6" +} + +data "cloudtemple_compute_host_cluster" "cluster" { + name = "clu001-ucs01" +} + +data "cloudtemple_compute_datastore_cluster" "sdrs" { + name = "sdrs001-LIVE" +} + +data "cloudtemple_compute_datastore" "ds" { + name = "ds001-data01" +} + +data "cloudtemple_compute_network" "vlan" { + name = "VLAN_201" +} + +# Distribuire dalla Content Library +resource "cloudtemple_compute_virtual_machine" "content_library_vm" { + name = "centos-from-cl-01" + + # Origine Content Library + content_library_id = data.cloudtemple_compute_content_library.public.id + content_library_item_id = data.cloudtemple_compute_content_library_item.centos.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_cluster_id = data.cloudtemple_compute_datastore_cluster.sdrs.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configurazione disco SO + os_disk { + capacity = 50 * 1024 * 1024 * 1024 # 50 GB + } + + # Configurazione adattatore di rete SO + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + } + + tags = { + source = "content-library" + } +} +``` + +**Spiegazioni**: +- I blocchi `os_disk` e `os_network_adapter` configurano le risorse del template +- Questi blocchi possono essere utilizzati solo al momento della creazione (vedere sezione dedicata) + +--- + +### Configurare Cloud-Init VMware + +**Obiettivo**: Automatizzare la configurazione della VM al primo avvio con Cloud-Init. + +**Prerequisiti**: Utilizzare un'immagine compatibile con Cloud-Init (ad es., Ubuntu Cloud Image in formato OVF). + +**File Cloud-Init**: + +Creare `cloud-init/user-data.yml`: + +```yaml +#cloud-config +hostname: my-server +fqdn: my-server.example.com + +users: + - name: admin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key-here + +packages: + - nginx + - git + - curl + +runcmd: + - systemctl enable nginx + - systemctl start nginx +``` + +Creare `cloud-init/network-config.yml`: + +```yaml +version: 2 +ethernets: + eth0: + dhcp4: false + addresses: + - 192.168.1.10/24 + gateway4: 192.168.1.1 + nameservers: + addresses: + - 8.8.8.8 + - 8.8.4.4 +``` + +**Codice Terraform**: + +```hcl +data "cloudtemple_compute_content_library" "local" { + name = "local-content-library" +} + +data "cloudtemple_compute_content_library_item" "ubuntu_cloudimg" { + content_library_id = data.cloudtemple_compute_content_library.local.id + name = "ubuntu-jammy-22.04-cloudimg" +} + +resource "cloudtemple_compute_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + content_library_id = data.cloudtemple_compute_content_library.local.id + content_library_item_id = data.cloudtemple_compute_content_library_item.ubuntu_cloudimg.id + + power_state = "on" + + # Configurazione Cloud-Init (datasource OVF VMware) + cloud_init = { + user-data = filebase64("./cloud-init/user-data.yml") + network-config = filebase64("./cloud-init/network-config.yml") + hostname = "my-server" + password = "RANDOM" + } +} +``` + +**Chiavi Cloud-Init supportate (VMware)**: +- `user-data`: Configurazione principale (base64) +- `network-config`: Configurazione di rete (base64) +- `public-keys`: Chiavi pubbliche SSH +- `hostname`: Nome host +- `password`: Password (o "RANDOM") +- `instance-id`: Identificatore univoco +- `seedfrom`: URL origine configurazione + +:::warning Limitazione + Cloud-Init viene eseguito solo al primo avvio della VM. +::: + +--- + +### Creare un disco virtuale e collegarlo a una VM + +**Obiettivo**: Aggiungere storage aggiuntivo a una macchina virtuale esistente. + +**Codice**: + +```hcl +# Fare riferimento a una VM esistente +data "cloudtemple_compute_virtual_machine" "existing_vm" { + name = "my-existing-vm" +} + +# Creare un disco virtuale +resource "cloudtemple_compute_virtual_disk" "data_disk" { + name = "data-disk-01" + + # Collegare alla VM + virtual_machine_id = data.cloudtemple_compute_virtual_machine.existing_vm.id + + # Dimensione disco + capacity = 100 * 1024 * 1024 * 1024 # 100 GB + + # Modalità disco + disk_mode = "persistent" + + # Tipo di provisioning + provisioning_type = "dynamic" +} +``` + +**Modalità disco disponibili**: +- `persistent`: Le modifiche vengono salvate immediatamente e permanentemente sul disco virtuale. +- `independent_nonpersistent`: Le modifiche apportate al disco virtuale vengono salvate in un log di ripristino ed eliminate allo spegnimento. +- `independent_persistent`: Le modifiche vengono salvate immediatamente e permanentemente sul disco virtuale. Non sono influenzate dagli snapshot. + +**Tipi di provisioning**: +- `dynamic`: Risparmia spazio di storage allocando dinamicamente lo spazio secondo necessità. La creazione è veloce. +- `staticImmediate`: Alloca tutto lo spazio disco alla creazione, ma i blocchi vengono azzerati alla prima scrittura. +- `staticDiffered`: Alloca e azzera tutto lo spazio disco alla creazione. + +--- + +### Creare un'interfaccia di rete e collegarla a una VM + +**Obiettivo**: Aggiungere una scheda di rete a una macchina virtuale. + +**Codice**: + +```hcl +# Recuperare la rete +data "cloudtemple_compute_network" "production_vlan" { + name = "PROD-VLAN-100" +} + +# Fare riferimento alla VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Creare un adattatore di rete +resource "cloudtemple_compute_network_adapter" "eth1" { + name = "Network adapter 2" + + # VM di destinazione + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Rete + network_id = data.cloudtemple_compute_network.production_vlan.id + + # Tipo di adattatore + type = "VMXNET3" + + # Connessione automatica all'accensione + connect_on_power_on = true + + # Indirizzo MAC (opzionale, generato automaticamente se omesso) + # mac_address = "00:50:56:xx:xx:xx" +} +``` + +:::info Tipi di adattatori di rete supportati + I tipi di adattatori compatibili utilizzabili dipendono dal SO utilizzato sulla Macchina Virtuale e dalla versione VMware. +::: + +--- + +### Creare un controller virtuale e collegarlo a una VM + +**Obiettivo**: Aggiungere un controller di disco a una macchina virtuale. + +**Codice**: + +```hcl +# Fare riferimento alla VM +data "cloudtemple_compute_virtual_machine" "vm" { + name = "my-vm" +} + +# Creare un controller SCSI +resource "cloudtemple_compute_virtual_controller" "scsi_controller" { + name = "SCSI controller 1" + + # VM di destinazione + virtual_machine_id = data.cloudtemple_compute_virtual_machine.vm.id + + # Tipo di controller + type = "SCSI" +} +``` + +**Tipi di controller**: +- `USB2` +- `USB3` +- `SCSI` +- `CD/DVD` +- `NVME` +- `PCI` + +--- + +## OpenSource IaaS + +### Creare una VM da un template + +**Obiettivo**: Distribuire una macchina virtuale da un template di catalogo. + +**Prerequisiti**: +- Accesso all'infrastruttura OpenSource di Cloud Temple +- Permessi richiesti: + - `compute_iaas_opensource_read` + - `compute_iaas_opensource_management` + - `compute_iaas_opensource_virtual_machine_power` + - `compute_iaas_opensource_infrastructure_read` + - `backup_iaas_opensource_read` + - `backup_iaas_opensource_write` + - `activity_read` + - `tag_read` + - `tag_write` + +**Codice**: + +```hcl +# Recuperare un template +data "cloudtemple_compute_iaas_opensource_template" "almalinux" { + name = "AlmaLinux 8" +} + +# Recuperare l'host +data "cloudtemple_compute_iaas_opensource_host" "host" { + name = "host-01" +} + +# Recuperare il repository di storage +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-local-storage" +} + +# Recuperare la rete +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "VLAN-100" +} + +# Recuperare la policy di backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +# Creare la VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "openstack_vm" { + name = "almalinux-vm-01" + power_state = "on" + + # Origine + template_id = data.cloudtemple_compute_iaas_opensource_template.almalinux.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + # Configurazione hardware + memory = 8 * 1024 * 1024 * 1024 # 8 GB + cpu = 4 + num_cores_per_socket = 2 + + # Opzioni + boot_firmware = "uefi" + secure_boot = false + auto_power_on = true + high_availability = "best-effort" + + # Disco SO (deve corrispondere al template) + os_disk { + name = "os-disk" + connected = true + size = 20 * 1024 * 1024 * 1024 # 20 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # Adattatore di rete SO + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + # Backup + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + # Ordine di avvio + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + environment = "production" + os = "almalinux" + } +} +``` + +**Spiegazioni**: +- `high_availability`: Opzioni disponibili: `disabled`, `restart`, `best-effort` (Vedi [documentazione](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) sull'Alta Disponibilità) +- `boot_firmware`: `bios` o `uefi` +- `secure_boot`: Solo con UEFI + +--- + +### Creare una VM dal Marketplace + +**Obiettivo**: Distribuire una VM dal Marketplace di Cloud Temple su OpenSource IaaS. + +**Codice**: + +```hcl +# Recuperare un elemento del Marketplace +data "cloudtemple_marketplace_item" "ubuntu_2404" { + name = "Ubuntu 24.04 LTS" +} + +data "cloudtemple_compute_iaas_opensource_storage_repository" "sr" { + name = "sr001-shared-storage" +} + +data "cloudtemple_compute_iaas_opensource_network" "network" { + name = "PROD-NETWORK" +} + +data "cloudtemple_backup_iaas_opensource_policy" "nobackup" { + name = "nobackup" +} + +# Distribuire dal Marketplace +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "marketplace_vm" { + name = "ubuntu-marketplace-01" + power_state = "on" + + # Origine Marketplace + marketplace_item_id = data.cloudtemple_marketplace_item.ubuntu_2404.id + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + + memory = 6 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 4 + boot_firmware = "uefi" + secure_boot = false + + auto_power_on = true + high_availability = "best-effort" + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + tx_checksumming = true + attached = true + } + + os_disk { + connected = true + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.nobackup.id + ] + + boot_order = [ + "Hard-Drive", + "DVD-Drive", + ] + + tags = { + source = "marketplace" + } +} +``` + +--- + +### Configurare la Replicazione + +**Obiettivo**: Configurare una policy di replicazione per una VM. + +**Codice**: + +```hcl +data "cloudtemple_compute_iaas_opensource_storage_repository" "replication_target" { + name = "target_storage_repository_name" + machine_manager_id = "availability_zone_id" +} + +# Creare una policy di replicazione +resource "cloudtemple_compute_iaas_opensource_replication_policy" "policy_hourly" { + name = "replication-policy-6h" + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.replication_target.id + + interval { + hours = 1 + } +} + +# Associare a una VM +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "replicated_vm" { + name = "replicated-vm-01" + + # ... configurazione standard ... + + # Associare la policy di replicazione + replication_policy_id = cloudtemple_compute_iaas_opensource_replication_policy.policy_hourly.id +} +``` + +**Spiegazioni**: +- `interval`: Intervallo di replicazione. Può essere specificato in `minutes` o `hours` +- `storage_repository_id`: Repository di Storage a cui verranno replicati i dischi della VM. Deve trovarsi su un'AZ diversa dalla VM originale + +--- + +### Configurare il Backup + +**Obiettivo**: Applicare una policy di backup a una VM. + +**Codice**: + +```hcl +# Recuperare le policy di backup +data "cloudtemple_backup_iaas_opensource_policy" "daily" { + name = "daily-backup" +} + +data "cloudtemple_backup_iaas_opensource_policy" "weekly" { + name = "weekly-backup" +} + +# VM con policy di backup multiple +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "backup_vm" { + name = "important-vm-01" + + # ... configurazione standard ... + + # È possibile applicare più policy + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id, + data.cloudtemple_backup_iaas_opensource_policy.weekly.id, + ] +} +``` + +:::info Backup obbligatorio + In un ambiente SecNumCloud, deve essere definita almeno una policy di backup per avviare la VM. +::: + +--- + +### Configurare l'Alta Disponibilità + +**Obiettivo**: Configurare il comportamento HA di una macchina virtuale. + +**Codice**: + +```hcl +# VM con HA disabilitato +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "no_ha" { + name = "dev-vm-01" + high_availability = "disabled" + # ... +} + +# VM con riavvio prioritario +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "priority_ha" { + name = "prod-vm-01" + high_availability = "restart" + # ... +} + +# VM con best-effort +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "besteff_ha" { + name = "test-vm-01" + high_availability = "best-effort" + # ... +} +``` + +**Modalità HA disponibili**: + +Vedere la documentazione sull'[Alta Disponibilità](https://docs.cloud-temple.com/iaas_opensource/concepts#haute-disponibilit%C3%A9) nell'infrastruttura OpenSource + +| Modalità | Descrizione | Utilizzo | +|----------|-------------|----------| +| `disabled` | Nessuna HA | Ambienti di sviluppo | +| `restart` | Riavvio ad alta priorità | Produzione critica | +| `best-effort` | Riavvio se risorse disponibili | Produzione standard | + +--- + +### Configurare Cloud-Init OpenSource + +**Obiettivo**: Automatizzare la configurazione con Cloud-Init (datasource NoCloud). + +**Prerequisiti**: Immagine compatibile con Cloud-Init NoCloud. + +**File Cloud-Init**: + +Creare `cloud-init/cloud-config.yml`: + +```yaml +#cloud-config +hostname: openiaas-server + +users: + - name: cloudadmin + sudo: ALL=(ALL) NOPASSWD:ALL + groups: sudo, docker + shell: /bin/bash + ssh_authorized_keys: + - ssh-rsa AAAAB3NzaC1yc2E... your-key + +packages: + - docker.io + - docker-compose + - htop + +runcmd: + - systemctl enable docker + - systemctl start docker + - usermod -aG docker cloudadmin +``` + +Creare `cloud-init/network-config.yml`: + +```yaml +version: 2 + ethernets: + ens160: + dhcp4: false + addresses: + - 0.0.0.0/24 + routes: + - to: default + via:: 0.0.0.0 + nameservers: + addresses: + - 0.0.0.0 +``` + +:::important Nota + Adattare la configurazione cloud-init alle proprie esigenze e alla versione di Cloud-Init installata sulla macchina. Il formato e la sintassi possono cambiare a seconda delle versioni. +::: + +**Codice Terraform**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "cloudinit_vm" { + name = "ubuntu-cloudinit-01" + power_state = "on" + + template_id = data.cloudtemple_compute_iaas_opensource_template.ubuntu_cloud.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + + auto_power_on = true + high_availability = "best-effort" + + os_disk { + connected = true + size = 30 * 1024 * 1024 * 1024 + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + attached = true + } + + # Configurazione Cloud-Init (datasource NoCloud) + cloud_init = { + cloud_config = file("./cloud-init/cloud-config.yml") + network_config = file("./cloud-init/network-config.yml") + } + + backup_sla_policies = [ + data.cloudtemple_backup_iaas_opensource_policy.daily.id + ] + + boot_order = ["Hard-Drive"] +} +``` + +**Differenza con VMware**: +- OpenSource utilizza il datasource **NoCloud** +- Chiavi supportate: `cloud_config` e `network_config` +- Non si usa `filebase64()`, utilizzare `file()` direttamente + +--- + +### Comprendere os_disk e os_network_adapter + +I blocchi `os_disk` e `os_network_adapter` sono blocchi speciali utilizzabili **solo durante la creazione** di una macchina virtuale da: + +- Content Library +- Template +- Marketplace di Cloud Temple +- Clone di una VM esistente + +:::info Informazione + Vengono utilizzati per fare riferimento a dischi virtuali e adattatori di rete distribuiti dal template per poter modificare i loro parametri successivamente senza doverli importare manualmente. Non creano in alcun modo una nuova risorsa. +::: + +**Caratteristiche importanti**: + +1. **Solo alla creazione**: Questi blocchi possono essere definiti solo durante il `terraform apply` iniziale +2. **Alternativa**: Utilizzare il comando `terraform import` per importarli manualmente + +--- + +### Utilizzare os_disk + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_os_disk" { + name = "vm-content-library" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configurare il disco SO esistente nel template + os_disk { + capacity = 100 * 1024 * 1024 * 1024 # Ridimensionare a 100 GB + disk_mode = "persistent" + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_os_disk" { + name = "openiaas-vm" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 8 * 1024 * 1024 * 1024 + cpu = 4 + num_cores_per_socket = 2 + power_state = "on" + + # Configurazione disco SO + os_disk { + name = "os-disk" + connected = true + size = 50 * 1024 * 1024 * 1024 # 50 GB + storage_repository_id = data.cloudtemple_compute_iaas_opensource_storage_repository.sr.id + } + + # ... altre configurazioni +} +``` + +--- + +### Utilizzare os_network_adapter + +**VMware IaaS**: + +```hcl +resource "cloudtemple_compute_virtual_machine" "vm_with_network" { + name = "vm-with-network" + + content_library_id = data.cloudtemple_compute_content_library.cl.id + content_library_item_id = data.cloudtemple_compute_content_library_item.item.id + + datacenter_id = data.cloudtemple_compute_virtual_datacenter.dc.id + host_cluster_id = data.cloudtemple_compute_host_cluster.cluster.id + datastore_id = data.cloudtemple_compute_datastore.ds.id + + # Configurare l'adattatore di rete del template + os_network_adapter { + network_id = data.cloudtemple_compute_network.vlan.id + auto_connect = true + connected = true + mac_address = "00:50:56:12:34:56" # Opzionale + } +} +``` + +**OpenSource IaaS**: + +```hcl +resource "cloudtemple_compute_iaas_opensource_virtual_machine" "vm_with_network" { + name = "openiaas-vm-network" + + template_id = data.cloudtemple_compute_iaas_opensource_template.template.id + host_id = data.cloudtemple_compute_iaas_opensource_host.host.id + + memory = 4 * 1024 * 1024 * 1024 + cpu = 2 + num_cores_per_socket = 2 + power_state = "on" + + # Configurazione adattatore di rete + os_network_adapter { + network_id = data.cloudtemple_compute_iaas_opensource_network.network.id + mac_address = "c2:db:4f:15:41:3e" # Opzionale + tx_checksumming = true + attached = true + } + + # ... altre configurazioni +} +``` + +:::info Nota + È possibile combinare entrambi gli approcci facendo riferimento ai dischi e/o agli adattatori di rete di una VM e aggiungendone altri tramite le risorse `cloudtemple_compute_iaas_vmware/opensource_virtual_disk` e `cloudtemple_compute_iaas_vmware/opensource_network_adapter` +::: + +--- + +**Best practice**: +1. Utilizzare `os_disk` e `os_network_adapter` per la configurazione iniziale del template +2. Utilizzare risorse dedicate per aggiungere risorse aggiuntive + +--- + +## Object Storage + +### Creare un bucket + +**Obiettivo**: Creare un bucket di object storage compatibile S3. + +**Prerequisiti**: Permesso `object-storage_write` + +**Codice**: + +```hcl +# Bucket privato +resource "cloudtemple_object_storage_bucket" "private_bucket" { + name = "my-private-bucket" + access_type = "private" +} + +# Bucket pubblico +resource "cloudtemple_object_storage_bucket" "public_bucket" { + name = "my-public-bucket" + access_type = "public" +} + +# Bucket con accesso personalizzato (whitelist IP) +resource "cloudtemple_object_storage_bucket" "custom_bucket" { + name = "my-custom-bucket" + access_type = "custom" + + # Whitelist IP/CIDR + whitelist = [ + "10.0.0.0/8", + "192.168.1.0/24", + "203.0.113.42/32" + ] +} + +# Bucket con versioning abilitato +resource "cloudtemple_object_storage_bucket" "versioned_bucket" { + name = "my-versioned-bucket" + access_type = "private" + versioning = "Enabled" +} + +# Output utili +output "bucket_endpoint" { + value = cloudtemple_object_storage_bucket.private_bucket.endpoint +} + +output "bucket_namespace" { + value = cloudtemple_object_storage_bucket.private_bucket.namespace +} +``` + +**Tipi di accesso**: +- `private`: Accesso limitato agli indirizzi IP del tenant +- `public`: Accesso pubblico in lettura +- `custom`: Accesso limitato agli IP in whitelist + +**Versioning**: +- `Enabled`: Abilita il versioning degli oggetti +- `Suspended`: Sospende il versioning (mantiene le versioni esistenti) + +--- + +### Creare un account di storage + +**Obiettivo**: Creare un account di storage con credenziali S3. + +**Codice**: + +```hcl +# Creare un account di storage +resource "cloudtemple_object_storage_storage_account" "app_account" { + name = "application-storage-account" +} + +# Output per utilizzare le credenziali +output "s3_access_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_key_id +} + +output "s3_secret_key" { + value = cloudtemple_object_storage_storage_account.app_account.access_secret_key + sensitive = true +} + +output "s3_endpoint" { + value = "https://${cloudtemple_object_storage_bucket.my_bucket.namespace}.s3.fr1.cloud-temple.com" +} +``` + +:::warning Informazioni sensibili + Le credenziali vengono visualizzate una sola volta. Archiviarle in modo sicuro (ad es., HashiCorp Vault, AWS Secrets Manager). +::: + +--- + +### Creare ACL tramite risorsa dedicata + +**Obiettivo**: Gestire i permessi di accesso al bucket con le ACL. + +**Codice**: + +```hcl +# Recuperare i ruoli disponibili +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +data "cloudtemple_object_storage_role" "admin" { + name = "admin" +} + +# Recuperare gli account di storage esistenti +data "cloudtemple_object_storage_storage_account" "dev_account" { + name = "dev-team-account" +} + +data "cloudtemple_object_storage_storage_account" "ops_account" { + name = "ops-team-account" +} + +# Bucket +resource "cloudtemple_object_storage_bucket" "shared_bucket" { + name = "shared-bucket" + access_type = "private" +} + +# ACL per il team dev (sola lettura) +resource "cloudtemple_object_storage_acl_entry" "dev_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.dev_account.name + role = data.cloudtemple_object_storage_role.read_only.name +} + +# ACL per il team ops (maintainer) +resource "cloudtemple_object_storage_acl_entry" "ops_acl" { + bucket = cloudtemple_object_storage_bucket.shared_bucket.name + storage_account = data.cloudtemple_object_storage_storage_account.ops_account.name + role = data.cloudtemple_object_storage_role.maintainer.name +} +``` + +**Ruoli disponibili**: +- `read_write`: Lettura e scrittura +- `write_only`: Solo scrittura +- `read_only`: Sola lettura +- `maintainer`: Accesso completo + +--- + +### Configurare le ACL direttamente nel bucket + +**Obiettivo**: Definire le ACL durante la creazione del bucket. + +**Codice**: + +```hcl +# Recuperare le risorse +data "cloudtemple_object_storage_storage_account" "account1" { + name = "storage-account-1" +} + +data "cloudtemple_object_storage_storage_account" "account2" { + name = "storage-account-2" +} + +data "cloudtemple_object_storage_role" "read_only" { + name = "read_only" +} + +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +# Bucket con ACL inline +resource "cloudtemple_object_storage_bucket" "bucket_with_acl" { + name = "bucket-with-inline-acl" + access_type = "private" + + # Definizione ACL nel bucket + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account1.name + role = data.cloudtemple_object_storage_role.read_only.name + } + + acl_entry { + storage_account = data.cloudtemple_object_storage_storage_account.account2.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} +``` + +**Differenza con le risorse ACL dedicate**: +- **Inline**: ACL definite direttamente nel bucket (più semplice per configurazioni statiche) +- **Risorsa dedicata**: ACL gestite separatamente (più flessibile, permette modifiche indipendenti) + +--- + +### Utilizzare i datasource + +**Obiettivo**: Interrogare i metadati del bucket ed elencare i file. + +**Codice**: + +```hcl +# Datasource per elencare i file del bucket +data "cloudtemple_object_storage_bucket_files" "my_bucket_files" { + bucket_name = cloudtemple_object_storage_bucket.my_bucket.name +} + +# Visualizzare tutti i file +output "all_files" { + value = data.cloudtemple_object_storage_bucket_files.my_bucket_files.files +} + +# Filtrare un file specifico +output "specific_file" { + value = [ + for file in data.cloudtemple_object_storage_bucket_files.my_bucket_files.files : + file if file.key == "config.json" + ] +} + +# Recuperare un account di storage esistente +data "cloudtemple_object_storage_storage_account" "existing_account" { + name = "production-account" +} + +output "account_access_key" { + value = data.cloudtemple_object_storage_storage_account.existing_account.access_key_id + sensitive = true +} +``` + +--- + +### Integrazione S3 con il provider AWS + +**Obiettivo**: Utilizzare il provider AWS per caricare file nell'object storage di Cloud Temple. + +**Codice**: + +```hcl +# Creare account e bucket +data "cloudtemple_object_storage_role" "maintainer" { + name = "maintainer" +} + +resource "cloudtemple_object_storage_storage_account" "upload_account" { + name = "upload-storage-account" +} + +resource "cloudtemple_object_storage_bucket" "upload_bucket" { + name = "upload-bucket" + access_type = "private" + + acl_entry { + storage_account = cloudtemple_object_storage_storage_account.upload_account.name + role = data.cloudtemple_object_storage_role.maintainer.name + } +} + +# Configurare il provider AWS per S3 di Cloud Temple +provider "aws" { + alias = "cloudtemple_s3" + region = "eu-west-3" + + # Utilizzare le credenziali di Cloud Temple + access_key = cloudtemple_object_storage_storage_account.upload_account.access_key_id + secret_key = cloudtemple_object_storage_storage_account.upload_account.access_secret_key + + # Endpoint Cloud Temple + endpoints { + s3 = "https://${cloudtemple_object_storage_bucket.upload_bucket.namespace}.s3.fr1.cloud-temple.com" + } + + # Configurazione per saltare la validazione AWS + skip_credentials_validation = true + skip_metadata_api_check = true + skip_requesting_account_id = true +} + +# Caricare un file +resource "aws_s3_object" "config_file" { + provider = aws.cloudtemple_s3 + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = "config/app-config.json" + source = "./files/app-config.json" + etag = filemd5("./files/app-config.json") +} + +# Caricare più file +resource "aws_s3_object" "static_files" { + provider = aws.cloudtemple_s3 + + for_each = fileset("./static/", "**/*") + + bucket = cloudtemple_object_storage_bucket.upload_bucket.name + key = each.value + source = "./static/${each.value}" + etag = filemd5("./static/${each.value}") +} + +# Verificare i file caricati +data "cloudtemple_object_storage_bucket_files" "uploaded_files" { + depends_on = [aws_s3_object.config_file] + bucket_name = cloudtemple_object_storage_bucket.upload_bucket.name +} + +output "uploaded_files_list" { + value = data.cloudtemple_object_storage_bucket_files.uploaded_files.files +} +``` + +--- + +## Conclusione + +Questa documentazione copre i principali casi d'uso del provider Terraform di Cloud Temple. Per approfondire: + +- Consultare la [documentazione ufficiale del provider](https://registry.terraform.io/providers/Cloud-Temple/cloudtemple/latest/docs) +- Esplorare gli [esempi su GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/tree/main/examples) +- Utilizzare la [Console Cloud Temple](https://shiva.cloud-temple.com) per identificare le risorse disponibili + +:::info Serve aiuto? + Per qualsiasi domanda o problema, consultare la [sezione Issues su GitHub](https://github.com/Cloud-Temple/terraform-provider-cloudtemple/issues) o contattare il supporto di Cloud Temple. +::: diff --git a/sidebars.ts b/sidebars.ts index 00a08b1f..fa508ec4 100644 --- a/sidebars.ts +++ b/sidebars.ts @@ -312,6 +312,16 @@ const sidebars: SidebarsConfig = { }, ], }, + { + type: 'category', + label: 'Provider Terraform', + items: [ + 'terraform/terraform', + 'terraform/concepts', + 'terraform/quickstart', + 'terraform/tutorials', + ], + }, { type: 'html', // Séparateur et titre value: `