Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Memorizzare lo stato di Terraform in un bucket Cloud Storage

In questo tutorial imparerai ad archiviare lo stato di Terraform in un bucket Cloud Storage.

Per impostazione predefinita, Terraform archivia lo stato localmente in un file denominato terraform.tfstate. Questa configurazione predefinita può rendere difficile l'utilizzo di Terraform per i team quando più utenti eseguono Terraform contemporaneamente e ogni macchina ha la propria interpretazione dell'infrastruttura attuale.

Per aiutarti a evitare questi problemi, questa pagina mostra come configurare uno stato remoto che rimanda a un bucket Cloud Storage. Lo stato remoto è una funzionalità dei backend di Terraform.

Obiettivi

Questo tutorial mostra gli aspetti seguenti:

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

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Cloud Storage

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Liberare spazio.

Cloud Storage comporta costi per archiviazione, operazioni di lettura e scrittura, traffico in uscita dalla rete e replica.

Il bucket Cloud Storage in questo tutorial ha Controllo versioni degli oggetti abilitato per conservare la cronologia dei deployment. L'abilitazione del controllo delle versioni degli oggetti aumenta i costi di archiviazione, che puoi ridurre configurando la gestione del ciclo di vita degli oggetti per eliminare le versioni precedenti dello stato.

Prima di iniziare

Nella Google Cloud console, attiva Cloud Shell.

Attiva Cloud Shell

Cloud Shell è preinstallato con Terraform.
Se utilizzi una shell locale, segui questi passaggi:
- Installa Terraform.
- Crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
  Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.
Crea o seleziona un Google Cloud progetto.
Ruoli richiesti per selezionare o creare un progetto
- Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico: puoi selezionare qualsiasi progetto su cui ti è stato concesso un ruolo.
- Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l' resourcemanager.projects.create autorizzazione. Scopri come concedere i ruoli.
Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.
- Crea un Google Cloud progetto:
```
gcloud projects create PROJECT_ID
```
  Sostituisci PROJECT_ID con un nome per il Google Cloud progetto che stai creando.
- Seleziona il Google Cloud progetto che hai creato:
```
gcloud config set project PROJECT_ID
```
  Sostituisci PROJECT_ID con il nome del Google Cloud progetto.
Verifica che la fatturazione sia attivata per il tuo Google Cloud progetto.
Abilita l'API Cloud Storage:
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
```
gcloud services enable storage.googleapis.com
```
Concedi i ruoli al tuo account utente. Esegui il seguente comando una volta per ciascuno dei seguenti ruoli IAM: roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto.
- USER_IDENTIFIER: l'identificatore del tuo account utente. account. Per esempi, consulta Rappresenta gli utenti del pool di forza lavoro nelle policy IAM.
- ROLE: il ruolo IAM che concedi al tuo account utente.
In alternativa, puoi creare un ruolo IAM personalizzato che contenga le seguenti autorizzazioni:
- storage.buckets.create
- storage.buckets.list
- storage.objects.get
- storage.objects.create
- storage.objects.delete
- storage.objects.update
Come best practice, ti consigliamo di controllare l'accesso al bucket e ai file di stato archiviati. Solo un piccolo gruppo di utenti (ad esempio, l'amministratore cloud principale e la persona che funge da amministratore alternativo o 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 di 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: questo valore 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 per archiviare il file di stato. Questo bucket è configurato per avere le seguenti proprietà:
  - force_destroy è impostato su false per garantire 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 è impostato su enforced per assicurarsi che i contenuti del bucket non vengano esposti accidentalmente al pubblico.
  - uniform_bucket_level_access è impostato su true per consentire il controllo dell'accesso al bucket e ai relativi contenuti utilizzando le autorizzazioni IAM anziché gli controllo dell'accesso accessi.
  - versioning è abilitato per garantire che le versioni precedenti dello stato vengano conservate nel bucket.
- local_file: un file locale. I contenuti di questo file indicano a Terraform di utilizzare il bucket Cloud Storage come backend remoto una volta creato il bucket.

Esegui il provisioning del bucket Cloud Storage

Inizializza Terraform:
```
terraform init
```
Quando esegui terraform init per la prima volta, il bucket Cloud Storage che hai 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 nel file main.tf:
```
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 file locale; i contenuti di questo file indicano a Terraform di utilizzare il 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 di eseguire la migrazione dello stato al nuovo bucket Cloud Storage. Quando richiesto, inserisci yes.

Dopo aver eseguito questo comando, lo stato di Terraform viene archiviato nel bucket Cloud Storage. Terraform recupera l'ultimo stato da questo bucket prima di eseguire un comando e lo invia al bucket dopo l'esecuzione di un comando.

Libera spazio

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 Google Cloud account 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 il seguente comando per eliminare le risorse di Terraform:
```
terraform destroy
```
Quando richiesto, inserisci yes.