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.

Déployer des flags de fonctionnalité

Ce guide de démarrage rapide vous explique comment créer, déployer et utiliser des flags de fonctionnalité avec App Lifecycle Manager.

Dans ce guide de démarrage rapide, vous apprendrez à installer et à configurer un fournisseur de flags, et à effectuer un flagging de fonctionnalité de base à l'aide des flags de fonctionnalité d'App Lifecycle Manager.

Avant de commencer

Connectez-vous à votre compte Google.

Si vous n'en possédez pas déjà un, vous devez en créer un.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the App Lifecycle Manager, Artifact Registry, Infrastructure Manager, Developer Connect, Cloud Build, Cloud Storage, Cloud Run and SaaS Config APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Create a service account:

Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator) and the Project IAM Admin role (roles/resourcemanager.projectIamAdmin). Learn how to grant roles.
In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

In the Service account description field, enter a description. For example, Service account for quickstart.
Click Create and continue.
Grant the Project > Owner role to the service account.

To grant the role, find the Select a role list, then select Project > Owner.

Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
Click Continue.
Click Done to finish creating the service account.

Installez la Google Cloud CLI.

Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the App Lifecycle Manager, Artifact Registry, Infrastructure Manager, Developer Connect, Cloud Build, Cloud Storage, Cloud Run and SaaS Config APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Create a service account:

Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator) and the Project IAM Admin role (roles/resourcemanager.projectIamAdmin). Learn how to grant roles.
In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

In the Service account description field, enter a description. For example, Service account for quickstart.
Click Create and continue.
Grant the Project > Owner role to the service account.

To grant the role, find the Select a role list, then select Project > Owner.

Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
Click Continue.
Click Done to finish creating the service account.

Installez la Google Cloud CLI.

Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

gcloud init

Créez une offre SaaS. Vous avez besoin d'une offre SaaS pour suivre ce guide de démarrage rapide. Pour en savoir plus sur la création d'une offre SaaS, consultez Créer une offre SaaS.

Accorder des autorisations au compte de service App Lifecycle Manager

Lorsque vous activez l'API App Lifecycle Manager, App Lifecycle Manager crée un compte de service. Ce compte de service est appelé service-PROJECT-NUMBER@gcp-sa-saasservicemgmt.iam.gserviceaccount.com, où PROJECT-NUMBER est le numéro de votre projet.

Accordez à ce compte de service les autorisations requises en exécutant la commande suivante :

gcloud projects add-iam-policy-binding `PROJECT_ID` \
    --member="serviceAccount:service-<var>`PROJECT_NUMBER`</var>@gcp-sa-saasservicemgmt.iam.gserviceaccount.com" \
    --role="roles/saasservicemgmt.serviceAgent"

Remplacez :

PROJECT_ID : identifiant de chaîne représentant l'ID de votre projet.
PROJECT_NUMBER : numéro de votre projet.

Rechercher la documentation de référence

Ce compte de service agit en votre nom pour diverses tâches, telles que le provisionnement d'unités.

Créer un dépôt dans Artifact Registry

Pour utiliser App Lifecycle Manager, vous avez besoin d'un dépôt dans Artifact Registry. Pour créer ce dépôt, exécutez la commande suivante dans votre terminal :

gcloud artifacts repositories create flags-quickstart \
    --repository-format=docker \
    --location=us-central1

Ce dépôt contiendra un plan (fichiers Terraform empaquetés) décrivant comment provisionner vos unités.

Créer un plan d'application de flagging de fonctionnalité

Créez un script Python qui lit un flag de fonctionnalité et utilisez-le pour créer et transférer une image Docker :

Créez un répertoire nommé alm_docker pour votre contexte de compilation Docker.

Dans le répertoire alm_docker, créez le fichier flags.py avec cet extrait :

import google.auth.transport.grpc
import google.auth.transport.requests
import grpc
import logging
import time
import os
import sys
from flask import Flask, jsonify

from openfeature import api
from openfeature.provider import ProviderEvent, ProviderStatus
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

# --- Flask App Setup ---
app = Flask(__name__)

# --- Logging Setup ---
logging.basicConfig(stream=sys.stdout) # Log to stdout for Cloud Run
log = logging.getLogger(__name__)
log.setLevel(logging.INFO) # Use INFO or DEBUG as needed

# --- OpenFeature/Flagd Setup ---
FLAG_KEY = "quickstart-flag"
DEFAULT_FLAG_VALUE = False

# Check for necessary environment variable
provider_id = os.environ.get("FLAGD_SOURCE_PROVIDER_ID")
if not provider_id:
  log.critical("FATAL: FLAGD_SOURCE_PROVIDER_ID environment variable not set.")
  sys.exit("FLAGD_SOURCE_PROVIDER_ID not set") # Exit if critical config is missing

log.info(f"Initializing OpenFeature provider for ID: {provider_id}")

def add_x_goog_request_params_header(config_name):
  return lambda context, callback: callback([("x-goog-request-params", f'name={config_name}')], None)

try:
  # Configure gRPC credentials for Google Cloud service
  configservice_credentials = grpc.composite_channel_credentials(
      grpc.ssl_channel_credentials(),
      grpc.metadata_call_credentials(
          google.auth.transport.grpc.AuthMetadataPlugin(
              google.auth.default()[0], # Get just the credentials from the tuple
              google.auth.transport.requests.Request()
          )
      ),
      grpc.metadata_call_credentials(
          add_x_goog_request_params_header(provider_id)
      )
  )

  # Set up the Flagd provider to connect to SaaS Config service
  # Using IN_PROCESS resolver type as recommended for direct gRPC connection
  provider = FlagdProvider(
      resolver_type=ResolverType.IN_PROCESS,
      host="saasconfig.googleapis.com",
      port=443,
      sync_metadata_disabled=True, # Important when using IN_PROCESS with direct service
      provider_id=provider_id,
      channel_credentials=configservice_credentials
  )
  api.set_provider(provider)
  client = api.get_client()

  initial_flag_value = client.get_boolean_value(FLAG_KEY, DEFAULT_FLAG_VALUE)
  log.info(f"***** STARTUP FLAG CHECK ***** Flag '{FLAG_KEY}' evaluated to: {initial_flag_value}")

except Exception as e:
  log.critical(f"FATAL: Failed to initialize OpenFeature provider: {e}", exc_info=True)
  # Depending on the desired behavior, you might exit or let Flask start
  # but log the critical failure. Exiting might be safer in production.
  sys.exit(f"Provider initialization failed: {e}")

# --- Flask Routes ---
@app.route('/')
def home():
  """Endpoint to check the feature flag's value."""
  log.info(f"Request received for flag: {FLAG_KEY}")
  try:
      # Get the flag value. Use the client initialized earlier.
      # The default value (DEFAULT_FLAG_VALUE) is returned if the flag isn't found
      # or if the provider isn't ready/errors occur during evaluation.
      flag_value = client.get_boolean_value(FLAG_KEY, DEFAULT_FLAG_VALUE)
      log.info(f"Evaluated flag '{FLAG_KEY}': {flag_value}")
      return jsonify({
          "flag_key": FLAG_KEY,
          "value": flag_value,
      })
  except Exception as e:
      log.error(f"Error evaluating flag '{FLAG_KEY}': {e}", exc_info=True)
      # Return an error response but keep the server running
      return jsonify({
          "error": f"Failed to evaluate flag {FLAG_KEY}",
          "details": str(e),
      }), 500

if __name__ == '__main__':
  port = int(os.environ.get('PORT', 8080))
  log.info(f"Starting Flask server on port {port}")
  app.run(host='0.0.0.0', port=port)

Ce script Python montre comment accéder aux flags de fonctionnalité dans votre application exécutée en tant qu'image Docker sur une unité App Lifecycle Manager. Il utilise les principes OpenFeature standards pour s'intégrer au service de configuration des flags de fonctionnalité App Lifecycle Manager (saasconfig.googleapis.com).

Créez un fichier texte nommé requirements.txt dans le répertoire alm_docker contenant cet extrait :

google-auth
grpcio>=1.49.1,<2.0.0dev
openfeature-sdk==0.8.0
openfeature-provider-flagd==0.2.2
requests 
typing_extensions
Flask>=2.0

Ajoutez Dockerfile au répertoire alm_docker avec :

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt
COPY flags.py .
CMD ["python", "flags.py"]

Exécutez cette commande dans votre environnement local pour créer et transférer l'image Docker :

export DOCKER_REGISTRY="us-central1-docker.pkg.dev/PROJECT_ID/flags-quickstart"
export FULL_IMAGE_PATH="${DOCKER_REGISTRY}/flags-quickstart:latest"
docker build -t "${FULL_IMAGE_PATH}" .
docker push "${FULL_IMAGE_PATH}"

Remplacez :

PROJECT_ID : identifiant de chaîne représentant l'ID de votre projet.

Dans votre environnement Docker, créez un répertoire alm_terraform.

Dans alm_terraform, créez les fichiers suivants :

main.tf

locals {
  config_path = "projects/${var.system_unit_project}/locations/${var.system_unit_location}/featureFlagsConfigs/${var.system_unit_name}"
  docker_image_path = "${var.system_unit_location}-docker.pkg.dev/${var.system_unit_project}/${var.docker_repo_name}/${var.docker_tag}"
}

provider "google" {
  project = var.system_unit_project
  region  = var.system_unit_location
}

resource "google_cloud_run_service" "flags_quickstart_service" {
  name     = var.cloud_run_service_name
  location = var.system_unit_location
  project  = var.system_unit_project

  template {
    spec {
      containers {
        image = local.docker_image_path 

        env {
          name  = "FLAGD_SOURCE_PROVIDER_ID"
          value = local.config_path
        }
      }
      service_account_name = var.actuation_sa
    }
  }
}

variables.tf

variable "actuation_sa" {
  description = "Actuation SA"
  type        = string
}

variable "system_unit_project" {
  description = "Project id - variable set by App Lifecycle Manager"
  type        = string
}

variable "system_unit_location" {
  description = "Location - variable set by App Lifecycle Manager"
  type        = string
}

variable "system_unit_name" {
  description = "Unit name- variable set by App Lifecycle Manager"
  type = string
}

variable "docker_repo_name" {
  description = "The name of the Artifact Registry repository where the Docker image is stored."
  type        = string
  default     = "flags-quickstart"
}

variable "docker_tag" {
  description = "The tag of the Docker image to deploy."
  type        = string
  default     = "flags-quickstart:latest"
}

variable "cloud_run_service_name" {
  description = "Name for the Cloud Run service to be created."
  type        = string
  default     = "saas-flags-quickstart-svc"
}

Dans le répertoire alm_terraform, exécutez cette commande pour empaqueter les fichiers de plan Terraform :
```
zip terraform-files.zip main.tf variables.tf
```

Utiliser le plan d'application pour créer une unité

Une fois que vous avez créé un plan d'application qui utilise des flags de fonctionnalité, vous devez créer un type d'unité App Lifecycle Manager (flags-unit-kind), puis créer une unité de ce type (flags-quickstart-unit).

Pour en savoir plus sur les unités et les types d'unité, consultez Modéliser et empaqueter les unités d' un déploiement.

Pour utiliser le plan d'application afin de créer une unité, procédez comme suit dans la gcloud CLI :

Pour empaqueter votre configuration Terraform en tant qu'image OCI (plan), créez un fichier nommé Dockerfile dans votre répertoire Terraform :
```
# syntax=docker/dockerfile:1-labs
FROM scratch
COPY --exclude=Dockerfile --exclude=.git --exclude=.gitignore . /
```

Créez et transférez Dockerfile vers votre dépôt Artifact Registry :

IMAGE_NAME="us-central1-docker.pkg.dev/PROJECT_ID/flags-quickstart/flags-quickstart-blueprint:latest"
ENGINE_TYPE=inframanager
ENGINE_VERSION=1.5.7

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

Remplacez :

PROJECT_ID : identifiant de chaîne représentant l'ID de votre projet.

Créez les ressources flags-unit-kind et flags-release :

# Create unit kind
gcloud beta app-lifecycle-manager unit-kinds create flags-unit-kind \
  --project=PROJECT_ID \
  --location=global \
  --saas=flags-quickstart-saas-offering

# Create release referencing the Blueprint image
gcloud beta app-lifecycle-manager releases create flags-release \
  --project=PROJECT_ID \
  --location=global \
  --unit-kind=flags-unit-kind \
  --blueprint-package=$IMAGE_NAME

Remplacez :

PROJECT_ID : identifiant de chaîne représentant l'ID de votre projet.

Créez l'unité flags-quickstart-unit :

gcloud beta app-lifecycle-manager units create flags-quickstart-unit \
  --project=PROJECT_ID \
  --location=us-central1 \
  --unit-kind=flags-unit-kind \
  --management-mode=user

Remplacez :

PROJECT_ID : identifiant de chaîne représentant l'ID de votre projet.

Créer et provisionner un flag de fonctionnalité

Avant qu'un flag de fonctionnalité App Lifecycle Manager puisse être utilisé par votre unité provisionnée, vous devez créer la ressource de flag de fonctionnalité et lancer un déploiement pour propager la configuration à l'unité.

Exécutez les commandes pour créer et provisionner le flag de fonctionnalité quickstart-flag :

Dans votre environnement, définissez les variables suivantes :

export FLAG_ID="quickstart-flag"
export FLAG_KEY="quickstart-flag"
export SAAS_OFFERING_ID="flags-quickstart-saas-offering"
export UNIT_KIND_ID="flags-unit-kind"
export UNIT_ID="flags-quickstart-unit"
export ROLLOUT_KIND_ID="flags-quickstart-rollout-kind"
export ROLLOUT_ID="flags-quickstart-rollout"

Créez la ressource de flag de fonctionnalité :

gcloud beta app-lifecycle-manager flags create ${FLAG_ID} \
  --project=${PROJECT_ID} \
  --key=${FLAG_KEY} \
  --flag-value-type=BOOL \
  --location=global \
  --unit-kind=${UNIT_KIND_ID}

Créez une révision :

export FLAG_REVISION_ID="${FLAG_ID}-rev1"
gcloud beta app-lifecycle-manager flags revisions create ${FLAG_REVISION_ID} \
  --project=${PROJECT_ID} \
  --flag=${FLAG_ID} \
  --location=global

Créez une version :

export FLAG_RELEASE_ID="${FLAG_ID}-rel1"
gcloud beta app-lifecycle-manager flags releases create ${FLAG_RELEASE_ID} \
  --project=${PROJECT_ID} \
  --flag-revisions=${FLAG_REVISION_ID} \
  --unit-kind=${UNIT_KIND_ID} \
  --location=global

Créez un genre de déploiement :

gcloud beta app-lifecycle-manager rollout-kinds create ${ROLLOUT_KIND_ID} \
  --project=${PROJECT_ID} \
  --unit-kind=${UNIT_KIND_ID} \
  --rollout-orchestration-strategy=Google.Cloud.Simple.AllAtOnce \
  --location=global

Créez le déploiement :

gcloud beta app-lifecycle-manager rollouts create ${ROLLOUT_ID} \
  --project=${PROJECT_ID} \
  --flag-release=${FLAG_RELEASE_ID} \
  --rollout-kind=${ROLLOUT_KIND_ID} \
  --location=global

Vous pouvez surveiller l'état du déploiement avec :

gcloud beta app-lifecycle-manager rollouts describe ${ROLLOUT_ID} --project=${PROJECT_ID} --location=global

Afficher la valeur du flag dans votre service en cours d'exécution

Une fois que votre unité App Lifecycle Manager a provisionné le service Cloud Run, vous pouvez vérifier que votre application s'exécute et évalue correctement le flag de fonctionnalité :

Dans la Google Cloud console, accédez à Cloud Run :

Accédez à Cloud Run
Recherchez le service nommé saas-flags-quickstart-svc dans la région us-central1. Une coche à côté de saas-flags-quickstart-svc indique qu'il s'exécute correctement.
Cliquez sur saas-flags-quickstart-svc pour afficher ses détails.

Accédez à saas-flags-quickstart-svc.
Sélectionnez l'onglet Journaux.
1. Dans les entrées de journal, recherchez un message semblable à celui-ci :
```
INFO:__main__:***** STARTUP FLAG CHECK ***** Flag 'quickstart-flag' evaluated to: false
```
  Cela confirme que l'application a démarré, s'est connectée au service de configuration SaaS et a évalué le quickstart-flag.
Pour accéder au point de terminaison public, cliquez sur l'onglet Mise en réseau.
1. Recherchez l'URL publique listée dans la section Points de terminaison.
2. Cliquez sur l'URL pour l'ouvrir dans votre navigateur ou utilisez un outil tel que curl pour y accéder depuis votre terminal (curl YOUR_SERVICE_URL, par exemple).
3. Chaque fois que vous accédez à l'URL, le service évalue le flag de fonctionnalité et renvoie sa valeur actuelle au format JSON. Exemple :
```
{
  "flag_key": "quickstart-flag",
  "value": false
}
```

Vous avez déployé un Google Cloud service qui lit un flag de fonctionnalité géré par App Lifecycle Manager. Vous pouvez essayer de modifier la valeur du flag et de créer un déploiement pour voir votre application prendre en compte la modification.

Libérer de l'espace

Pour éviter que les ressources utilisées dans cette démonstration soient facturées sur votre Google Cloud compte pour les ressources utilisées sur cette page, procédez comme suit :

(Facultatif) Supprimez le projet.

Si vous avez déployé la solution dans un nouveau Google Cloud projet et que vous n'en avez plus besoin, supprimez-le en procédant comme suit :

Dans la Google Cloud console, accédez à la page Gérer les ressources.
Accéder à la page "Gérer les ressources"
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Lorsque vous y êtes invité, saisissez l'ID du projet, puis cliquez sur Arrêter.

Étape suivante

Essayez le guide de démarrage rapide Déployer des flags de fonctionnalité autonomes pour utiliser des flags indépendamment des déploiements gérés par App Lifecycle Manager.
Explorez les guides d'intégration spécifiques à un langage (Python, Java, Go).
Consultez la présentation d'App Lifecycle Manager pour en savoir plus sur App Lifecycle Manager.