Nous aimerions recueillir vos commentaires sur les fonctionnalités et l'expérience utilisateur de nos indicateurs de fonctionnalité. Pour nous faire part de vos commentaires et influencer la conception de nos produits, remplissez ce formulaire.

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

Créer et importer un plan

Un plan est une configuration Terraform empaquetée sous la forme d'une image Open Container Initiative (OCI). La configuration Terraform spécifie l'infrastructure et l'application sur lesquelles App Lifecycle Manager effectue le déploiement Google Cloud.

Cette page explique comment créer une image OCI à partir de configurations Terraform existantes et comment l'importer dans App Lifecycle Manager.

Pour en savoir plus sur ces configurations Terraform, consultez la section Plans dans App Lifecycle Manager.

Avant de commencer

Assurez-vous d'avoir activé App Lifecycle Manager.
Dans le projet que vous utilisez pour App Lifecycle Manager, assurez-vous de disposer d'un dépôt Artifact Registry défini au format Docker. Pour en savoir plus, consultez la section Créer un dépôt pour App Lifecycle Manager.
Identifiez les configurations Terraform que vous souhaitez déployer à l'aide d'App Lifecycle Manager.
- Pour savoir comment modéliser l'offre SaaS à l'aide de plans, consultez Déterminer le modèle de l'offre SaaS
- Pour en savoir plus sur les exigences concernant la configuration Terraform, consultez Exigences concernant les plans.

Créer et importer le plan

Pour déployer les configurations Terraform à l'aide d'App Lifecycle Manager, vous devez procéder comme suit : Google Cloud

Empaqueter les configurations Terraform dans des images OCI. Ces images OCI sont appelées plans.
Placer ces images OCI dans le dépôt Artifact Registry que vous avez identifié ou configuré.

Selon la façon dont vous choisissez de créer et d'importer le plan, vous pouvez effectuer toutes les étapes manuellement ou laisser App Lifecycle Manager en effectuer certaines.

Vous pouvez créer l'image OCI et l'importer dans le dépôt à l'aide de l'une des méthodes suivantes :

Importer une archive ZIP contenant la configuration Terraform. App Lifecycle Manager utilise l'archive ZIP pour créer l'image OCI.

Pour en savoir plus, consultez la section Importer une archive ZIP.
Connecter un dépôt Git contenant les fichiers Terraform. App Lifecycle Manager utilise les fichiers pour créer l'image OCI. App Lifecycle Manager utilise ensuite Cloud Build pour créer et importer le plan chaque fois que vous mettez à jour votre dépôt.

Pour en savoir plus, consultez la section Se connecter à un dépôt Git.
Créer l'image OCI en local et l'importer dans le dépôt d'Artifact Registry.

Pour en savoir plus, consultez la section suivante : Créer et importer une image manuellement.
Automatiser la création et l'importation de l'image OCI dans un dépôt d'Artifact Registry. L'automatisation de ce processus vous permet d'intégrer App Lifecycle Manager dans un pipeline CI/CD.

Pour en savoir plus, consultez la section Automatiser la création de plans.

Importer une archive ZIP

Vous pouvez créer une archive ZIP des fichiers Terraform. Vous importez cette archive dans App Lifecycle Manager lorsque vous créez une version ou un type d'unité. App Lifecycle Manager utilise l'archive ZIP pour créer l'image OCI requise.

Pour fournir un plan à l'aide d'une archive ZIP, procédez comme suit :

Accédez au répertoire de votre projet Terraform.
Créez une archive ZIP contenant la configuration Terraform.
- Assurez-vous que :
  - L'archive ZIP ne contient que vos fichiers Terraform. Par exemple, main.tf, variables.tf, outputs.tf, versions.tf et les modules.
  - L'archive ZIP ne contient pas de fichiers inutiles, par exemple les répertoires .git ou un Dockerfile.
- La commande permettant de créer une archive ZIP peut ressembler à ceci : zip terraform-files.zip main.tf outputs.tf variables.tf versions.tf
Importez l'archive ZIP lorsque vous créez une version ou lorsque vous créez un type d'unité.

App Lifecycle Manager utilise l'archive ZIP pour créer l'image OCI requise et l'importe dans le dépôt Artifact Registry.

Se connecter à un dépôt Git

Si vous stockez votre configuration Terraform dans un dépôt Git, vous pouvez connecter App Lifecycle Manager à ce dépôt. App Lifecycle Manager utilise les fichiers pour créer l'image OCI requise lorsque vous créez un type d'unité ou une version.

Pour fournir un plan à l'aide d'un dépôt Git, procédez comme suit :

Assurez-vous que vos fichiers Terraform se trouvent dans le répertoire racine de votre dépôt Git.
Connectez votre dépôt Git à App Lifecycle Manager lorsque vous créez une version ou lorsque vous créez un type d'unité.

App Lifecycle Manager utilise Developer Connect pour se connecter au dépôt Git. Pour en savoir plus sur Developer Connect, consultez la documentation de Developer Connect.

App Lifecycle Manager utilise les fichiers Terraform du dépôt Git pour créer l'image OCI requise et l'importe dans le dépôt Artifact Registry.

Cette intégration automatise le processus de création de plans chaque fois que vous mettez à jour votre code Terraform dans votre dépôt. Lorsque des modifications sont apportées au dépôt Git associé, App Lifecycle Manager utilise les fichiers modifiés pour créer automatiquement une image OCI, puis l'importe dans le dépôt Artifact Registry.

Créer et importer une image manuellement

Cette méthode vous permet de contrôler précisément le processus de création de plans.

Pour créer un plan manuellement, procédez comme suit :

Dans le répertoire racine de vos fichiers Terraform, créez un fichier nommé Dockerfile avec le contenu suivant :
```
# syntax=docker/dockerfile:1-labs
FROM scratch
COPY --exclude=Dockerfile --exclude=.git --exclude=.gitignore . /
```
Ce Dockerfile utilise une image de base minimale (scratch). Envisagez d'inclure dockerignore à la commande pour exclure les fichiers qui ne sont pas pertinents, tels que :
- le Dockerfile lui-même
- le répertoire .git
- le fichier .gitignore
Si vous ne disposez pas d'un compilateur Docker, créez un compilateur docker-container à l'aide de docker buildx en exécutant la commande suivante :
```
docker buildx create --name container --driver=docker-container
```

Exécutez la commande docker buildx build suivante à partir de votre répertoire Terraform pour créer et importer le plan dans 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 .

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet
REPOSITORY_NAME: nom de votre dépôt Artifact Registry
IMAGE_NAME : nom de votre image de plan
TAG: tag de votre version d'image (par exemple, latest ou v1.0.0). Le choix d'un tag descriptif vous permet de gérer efficacement les versions du plan.
TERRAFORM_VERSION: version de Terraform à utiliser. Pour obtenir la liste des versions compatibles avec Infrastructure Manager, consultez la section Versions Terraform compatibles.

Une commande peut ressembler à l'exemple suivant :

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'image OCI se trouve dans le dépôt Artifact Registry.

Pour utiliser cette image avec App Lifecycle Manager, sélectionnez-la lorsque vous créez une version, ou lorsque vous créez un type d'unité.

Automatiser la création de plans

Vous pouvez automatiser la création de l'image OCI et l'importation dans Artifact Registry à l'aide de Cloud Build. Vous pouvez configurer un déclencheur pour que, chaque fois que le code Terraform est modifié, l'image OCI soit automatiquement créée et importée dans Artifact Registry.

Pour configurer cette automatisation, procédez comme suit :

À la racine de votre dépôt Terraform, créez un fichier cloudbuild.yaml avec la configuration suivante :

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