Questa pagina è stata tradotta dall'API Cloud Translation.

Archivia lo stato di Terraform in un bucket Cloud Storage

In questo tutorial imparerai ad archiviare lo stato di Terraform in un ambiente Cloud Storage di sincronizzare la directory di una VM con un bucket.

Per impostazione predefinita, Terraform archivia lo stato localmente in un file denominato terraform.tfstate. Questa configurazione predefinita può rendono difficile l'utilizzo di Terraform per i team quando più utenti eseguono Terraform allo stesso tempo e ogni macchina ha una propria comprensione del processo dell'infrastruttura.

Per aiutarti a evitare questi problemi, in questa pagina viene illustrato come configurare un stato remoto che punta a una nel bucket Cloud Storage. Lo stato remoto è una funzionalità Backend Terraform.

Obiettivi

Questo tutorial illustra come:

Utilizzare Terraform per eseguire il provisioning di un bucket Cloud Storage da archiviare lo stato di Terraform.
Aggiungi il modello nel file di configurazione di Terraform per eseguire la migrazione dello stato dal backend locale al bucket Cloud Storage.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Cloud Storage

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Cloud Storage comporta costi per l'archiviazione, le operazioni di lettura e scrittura, il traffico in uscita dalla rete e la replica.

Il bucket Cloud Storage in questo tutorial ha Oggetto Controllo delle versioni abilitato per mantenere la cronologia dei tuoi deployment di machine learning. Abilitando il controllo delle versioni degli oggetti aumenta i costi di archiviazione, mitigare il problema configurando la Gestione del ciclo di vita degli oggetti per eliminare le versioni precedenti dello stato.

Prima di iniziare

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Cloud Shell è preinstallato con Terraform.
Se utilizzi una shell locale, segui questi passaggi:
- Installa Terraform.
- Create local authentication credentials for your user account:
```
gcloud auth application-default login
```
  If an authentication error is returned, confirm that you have configured the gcloud CLI to use Workforce Identity Federation.
Create or select a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
- Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
  Replace PROJECT_ID with a name for the Google Cloud project you are creating.
- Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
  Replace PROJECT_ID with your Google Cloud project name.
Make sure that billing is enabled for your Google Cloud project.
Enable the Cloud Storage API:
```
gcloud services enable storage.googleapis.com
```
Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For examples, see Represent workforce pool users in IAM policies.
- Replace ROLE with each individual role.
In alternativa, puoi creare una ruolo IAM personalizzato che contiene le seguenti autorizzazioni:
- storage.buckets.create
- storage.buckets.list
- storage.objects.get
- storage.objects.create
- storage.objects.delete
- storage.objects.update
Come best practice, consigliamo l'accesso al bucket e allo stato che i file archiviati lì sono controllati. Solo un piccolo gruppo di utenti (ad esempio, l'amministratore principale del cloud e la persona che agisce in qualità di amministratore di backup) deve disporre delle autorizzazioni di amministratore per il bucket. Gli altri sviluppatori devono disporre delle autorizzazioni per scrivere e leggere solo gli oggetti nel bucket.

Prepara l'ambiente

Clona il repository GitHub contenente gli esempi di Terraform:

git clone https://github.com/terraform-google-modules/terraform-docs-samples.git --single-branch

Passa alla directory di lavoro:

cd terraform-docs-samples/storage/remote_terraform_backend_template

Esamina i file Terraform

Esamina il file main.tf:
```
cat main.tf
```
L'output è simile al seguente
```
resource "random_id" "default" {
  byte_length = 8
}

resource "google_storage_bucket" "default" {
  name     = "${random_id.default.hex}-terraform-remote-backend"
  location = "US"

  force_destroy               = false
  public_access_prevention    = "enforced"
  uniform_bucket_level_access = true

  versioning {
    enabled = true
  }
}

resource "local_file" "default" {
  file_permission = "0644"
  filename        = "${path.module}/backend.tf"

  # You can store the template in a file and use the templatefile function for
  # more modularity, if you prefer, instead of storing the template inline as
  # we do here.
  content = <<-EOT
  terraform {
    backend "gcs" {
      bucket = "${google_storage_bucket.default.name}"
    }
  }
  EOT
}
```
Questo file descrive le seguenti risorse:
- random_id: viene aggiunto al nome del bucket Cloud Storage per garantire un nome univoco per il bucket Cloud Storage.
- google_storage_bucket: il bucket Cloud Storage da archiviare il file di stato. Questo bucket è configurato per avere le seguenti proprietà:
  - force_destroy è impostato su false per assicurarsi che il bucket non venga eliminato se contiene oggetti. In questo modo, le informazioni sullo stato nel bucket non vengono eliminate accidentalmente.
  - public_access_prevention sia impostato su enforced per assicurarti che i contenuti del bucket non vengano esposti accidentalmente al pubblico.
  - uniform_bucket_level_access è impostato su true per consentire il controllo l'accesso al bucket e ai suoi contenuti Autorizzazioni IAM anziché elenchi di controllo dell'accesso.
  - versioning è abilitato per garantire che le versioni precedenti dello stato vengono conservati nel bucket.
- local_file: un file locale. I contenuti di questo file indicano a Terraform utilizzare il bucket Cloud Storage come backend remoto una volta viene creato un bucket Cloud Storage.

Esegui il provisioning del bucket Cloud Storage

Inizializza Terraform:
```
terraform init
```
Quando esegui terraform init per la prima volta, il bucket Cloud Storage specificato nel file main.tf non esiste ancora, quindi Terraform inizializza un backend locale per archiviare lo stato nel file system locale.
Applica la configurazione per eseguire il provisioning delle risorse descritte in main.tf file:
```
terraform apply
```
Quando richiesto, inserisci yes.

Quando esegui terraform apply per la prima volta, Terraform esegue il provisioning del bucket Cloud Storage per l'archiviazione dello stato. Crea anche un'istanza file; i contenuti di questo file indicano a Terraform di utilizzare Bucket Cloud Storage come backend remoto per archiviare lo stato.

Esegui la migrazione dello stato al bucket Cloud Storage

Esegui la migrazione dello stato di Terraform al backend Cloud Storage remoto:
```
terraform init -migrate-state
```
Terraform rileva che hai già un file di stato in locale e ti chiede per eseguire la migrazione dello stato nel nuovo bucket Cloud Storage. Quando richiesto, inserisci yes.

Dopo aver eseguito questo comando, lo stato di Terraform viene archiviato nel bucket Cloud Storage. Terraform estrae lo stato più recente da questo bucket prima di eseguire un comando e lo inserisce nel bucket dopo l'esecuzione di un comando.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

Apri il file main.tf.
Nella risorsa google_storage_bucket.default, aggiorna il valore di force_destroy a true.
Applica la configurazione aggiornata:
```
terraform apply
```
Quando richiesto, inserisci yes.
Elimina il file di stato:
```
rm backend.tf
```
Riconfigura il backend in modo che sia locale:
```
terraform init -migrate-state
```
Quando richiesto, inserisci yes.
Esegui questo comando per eliminare le risorse Terraform:
```
terraform destroy
```
Quando richiesto, inserisci yes.