Siamo alla ricerca di feedback sulle funzionalità dei flag di funzionalità e sull'esperienza utente. Registra il tuo interesse a fornire feedback e influenzare la progettazione del nostro prodotto compilando questo modulo.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Creare e caricare un progetto iniziale

Un progetto è una configurazione Terraform pacchettizzata come immagine Open Container Initiative (OCI). La configurazione Terraform specifica l'infrastruttura e l'applicazione su cui viene eseguito il deployment di App Lifecycle Manager Google Cloud.

Questa pagina descrive come creare un'immagine OCI dalle configurazioni Terraform esistenti e come caricarle in App Lifecycle Manager.

Per i dettagli su queste configurazioni Terraform, consulta Progetti in App Lifecycle Manager.

Prima di iniziare

Assicurati di aver abilitato App Lifecycle Manager.
Nel progetto che utilizzi per App Lifecycle Manager, assicurati di avere un repository Artifact Registry impostato sul formato Docker. Per maggiori dettagli, consulta Creare un repository per App Lifecycle Manager.
Identifica le configurazioni Terraform di cui vuoi eseguire il deployment utilizzando App Lifecycle Manager.
- Per i dettagli su come decidere come modellare l'offerta dell'app utilizzando i progetti, consulta Determinare il modello dell'offerta dell'app
- Per i dettagli sui requisiti della configurazione Terraform, consulta Requisiti del progetto.

Creare e caricare il progetto

Per eseguire il deployment delle configurazioni Terraform Google Cloud utilizzando App Lifecycle Manager, devi:

Pacchettizzare le configurazioni Terraform in immagini OCI. Queste immagini OCI sono chiamate progetti.
Inserire queste immagini OCI nel repository Artifact Registry che hai identificato o configurato.

A seconda di come scegli di creare e caricare il progetto, puoi eseguire tutti i passaggi manualmente oppure App Lifecycle Manager può eseguire alcuni passaggi.

Puoi creare l'immagine OCI e caricarla nel repository utilizzando uno dei seguenti metodi:

Carica un archivio zip contenente la configurazione Terraform. App Lifecycle Manager utilizza il file ZIP per creare l'immagine OCI.

Per i dettagli, consulta la sezione seguente: Caricare un file ZIP.
Connetti un repository Git contenente i file Terraform. App Lifecycle Manager utilizza i file per creare l'immagine OCI. App Lifecycle Manager utilizza quindi Cloud Build per creare e caricare il progetto ogni volta che aggiorni il repository.

Per i dettagli, consulta la sezione seguente: Connettersi a un repository Git.
Crea l'immagine OCI in locale ed esegui il push dell'immagine nel repository in Artifact Registry.

Per i dettagli, consulta la sezione seguente: Creare ed eseguire il push di un'immagine manualmente.
Automatizza la creazione e il push dell'immagine OCI in un repository in Artifact Registry. L'automazione di questo processo ti aiuta a incorporare App Lifecycle Manager in una pipeline CI/CD.

Per i dettagli, consulta la sezione seguente: Automatizzare la creazione di progetti.

Caricare un file ZIP

Puoi creare un file ZIP dei file Terraform. Carica questo archivio in App Lifecycle Manager quando crei una release o un tipo di unità. App Lifecycle Manager utilizza il file ZIP per creare l'immagine OCI richiesta.

Per fornire un progetto utilizzando un file ZIP:

Vai alla directory del progetto Terraform.
Crea un file ZIP contenente la configurazione Terraform.
- Assicurati che:
  - L'archivio zip contenga solo i file Terraform. Ad esempio, main.tf, variables.tf, outputs.tf, versions.tf e moduli.
  - L'archivio zip non contenga file non necessari, ad esempio directory .git o un Dockerfile.
- Il comando per creare un file ZIP potrebbe essere simile a questo: zip terraform-files.zip main.tf outputs.tf variables.tf versions.tf
Carica l'archivio zip quando crei una release o quando crei un tipo di unità.

App Lifecycle Manager utilizza il file ZIP per creare l'immagine OCI richiesta ed esegue il push nel repository Artifact Registry.

Connettersi a un repository Git

Se memorizzi la configurazione Terraform in un repository Git, puoi connettere App Lifecycle Manager a questo repository. App Lifecycle Manager utilizza i file per creare l'immagine OCI richiesta quando crei un tipo di unità o una release.

Per fornire un progetto utilizzando un repository Git:

Assicurati che i file Terraform si trovino nella directory root del repository Git.
Connetti il repository Git ad App Lifecycle Manager quando crei una release o quando crei un tipo di unità.

App Lifecycle Manager utilizza Developer Connect per connettersi al repository Git. Per maggiori dettagli su Developer Connect, consulta la documentazione di Developer Connect.

App Lifecycle Manager utilizza i file Terraform del repository Git per creare l'immagine OCI richiesta ed esegue il push nel repository Artifact Registry.

Questa integrazione automatizza il processo di creazione del progetto ogni volta che aggiorni il codice Terraform nel repository. Quando vengono apportate modifiche al repository Git collegato, App Lifecycle Manager utilizza i file modificati per creare automaticamente una nuova immagine OCI e quindi esegue il push nel repository Artifact Registry.

Creare ed eseguire il push di un'immagine manualmente

Questo metodo ti consente di controllare in modo granulare il processo di creazione del progetto.

Per creare un progetto manualmente:

Nella directory root dei file Terraform, crea un file denominato Dockerfile con i seguenti contenuti:
```
# syntax=docker/dockerfile:1-labs
FROM scratch
COPY --exclude=Dockerfile --exclude=.git --exclude=.gitignore . /
```
Questo Dockerfile utilizza un'immagine di base minima (scratch). Valuta la possibilità di includere dockerignore nel comando per escludere i file non pertinenti, ad esempio:
- Il Dockerfile stesso
- La directory .git
- Il file .gitignore
Se non hai un builder Docker, crea un builder docker-container utilizzando docker buildx con il seguente comando:
```
docker buildx create --name container --driver=docker-container
```

Esegui il seguente comando docker buildx build dalla directory Terraform per creare ed eseguire il push del progetto in Artifact Registry:

IMAGE_NAME=us-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/IMAGE_NAME:TAG
ENGINE_TYPE=inframanager
ENGINE_VERSION=TERRAFORM_VERSION

docker buildx build -t $IMAGE_NAME \
  --builder=container \
  --push \
  --annotation "com.easysaas.engine.type=$ENGINE_TYPE" \
  --annotation "com.easysaas.engine.version=$ENGINE_VERSION" \
  --provenance=false .

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
REPOSITORY_NAME: il nome del repository Artifact Registry.
IMAGE_NAME: un nome per l'immagine del progetto.
TAG: un tag per la versione dell'immagine (ad esempio, latest o v1.0.0). La scelta di un tag descrittivo ti aiuta a gestire in modo efficace le versioni del progetto.
TERRAFORM_VERSION: la versione supportata di Terraform da utilizzare. Per l'elenco delle versioni supportate da Infrastructure Manager, consulta Versioni di Terraform supportate.

Un comando potrebbe essere simile al seguente esempio:

IMAGE_NAME=us-docker.pkg.dev/saas-docs-testing/blueprints-repo/my-terraform-blueprint:v1.0.0
ENGINE_TYPE=inframanager
ENGINE_VERSION=1.5.7

docker buildx build -t $IMAGE_NAME \
  --builder=container \
  --push \
  --annotation "com.easysaas.engine.type=$ENGINE_TYPE" \
  --annotation "com.easysaas.engine.version=$ENGINE_VERSION" \
  --provenance=false .

L'immagine OCI si trova nel repository Artifact Registry.

Per utilizzare questa immagine con App Lifecycle Manager, selezionala quando crei una release, o quando crei un tipo di unità.

Automatizzare la creazione di progetti

Puoi automatizzare la creazione dell'immagine OCI e il push in Artifact Registry utilizzando Cloud Build. Puoi configurare un trigger in modo che ogni volta che il codice Terraform viene modificato, l'immagine OCI venga creata automaticamente e venga eseguito il push in Artifact Registry.

Per configurare questa automazione:

Nella directory root del repository Terraform, crea un file cloudbuild.yaml con la seguente configurazione:

steps:
- id: 'Create Dockerfile'
  name: 'bash'
  args: ['-c', 'echo -e "# syntax=docker/dockerfile:1-labs\nFROM scratch\nCOPY --exclude=Dockerfile.Blueprint --exclude=.git --exclude=.gitignore . /" > Dockerfile.Blueprint']
- id: 'Create docker-container driver'
  name: 'docker'
  args: ['buildx', 'create', '--name', 'container', '--driver=docker-container']
- id: 'Build and Push docker image'
  name: 'docker'
  args: ['buildx', 'build', '-t', '${_IMAGE_NAME}', '--builder=container', '--push', '--annotation', 'com.easysaas.engine.type=${_ENGINE_TYPE}','--annotation', 'com.easysaas.engine.version=${_ENGINE_VERSION}', '--provenance=false','-f', 'Dockerfile.Blueprint', '.']
serviceAccount: '${_SERVICE_ACCOUNT}'
substitutions:
  _SERVICE_ACCOUNT: 'projects/PROJECT_ID/serviceAccounts/CLOUD_BUILD_SERVICE_ACCOUNT'
  _IMAGE_NAME: 'us-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/IMAGE_NAME:latest'
  _ENGINE_TYPE: 'inframanager'
  _ENGINE_VERSION: 'TERRAFORM_VERSION'
options:
  logging: CLOUD_LOGGING_ONLY