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 uses AI technology to translate content into your preferred language. AI translations can contain errors.

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 App Lifecycle Manager esegue il deployment Google Cloud.

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

Per i dettagli di queste configurazioni Terraform, vedi 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, vedi 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 SaaS utilizzando i progetti, vedi Determinare il modello dell'offerta SaaS
- Per i dettagli sui requisiti della configurazione Terraform, vedi Requisiti dei progetti.

Creare e caricare il progetto

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

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 l'archivio zip per creare l'immagine OCI.

Per i dettagli, consulta la sezione seguente: Caricare un archivio 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 dei progetti.

Caricare un archivio zip

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

Per fornire un progetto utilizzando un archivio zip:

Vai alla directory del progetto Terraform.
Crea un archivio 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 archivio 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 l'archivio 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 dei progetti 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 poi esegue il push nel repository Artifact Registry.

Creare ed eseguire il push di un'immagine manualmente

Questo metodo ti offre un controllo granulare sul processo di creazione dei progetti.

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, vedi 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 dei 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