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 utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Utiliser des flags de fonctionnalité autonomes

Découvrez comment utiliser les flags de fonctionnalité d'App Lifecycle Manager en tant que service autonome pour gérer la disponibilité des fonctionnalités dans vos applications, même si elles ne sont pas déployées ni gérées par App Lifecycle Manager.

Introduction

Ce guide de démarrage rapide vous explique comment utiliser les fonctionnalités robustes de flag de fonctionnalité et de déploiement contrôlé d'App Lifecycle Manager sans avoir à utiliser App Lifecycle Manager pour le provisionnement de l'infrastructure (comme le déploiement de VM ou de services Cloud Run à l'aide de plans Terraform). Cette approche est idéale si vous gérez l'infrastructure de votre application de manière indépendante, mais que vous souhaitez utiliser App Lifecycle Manager pour gérer les flags de fonctionnalité de manière sécurisée.

Dans cette approche autonome, vous allez :

Modélisez votre système avec des ressources App Lifecycle Manager légères : créez des Units App Lifecycle Manager pour représenter les composants de votre infrastructure existante (par exemple, un déploiement de microservice spécifique, un environnement de locataire, une instance binaire unique). Ces unités servent uniquement de cibles pour les configurations de flags et n'impliquent pas le déploiement d'une infrastructure à l'aide de plans App Lifecycle Manager.
Définir et distribuer des flags : utilisez l'API App Lifecycle Manager ou la console Google Cloud pour créer des flags de fonctionnalité. Gérez leur cycle de vie à l'aide d'App Lifecycle Manager Rollouts pour assurer une propagation sûre et progressive des modifications de configuration vers votre Units modélisé. Cela garantit la cohérence et la sécurité opérationnelles, même lorsque vous ne gérez que des indicateurs.
Intégrer à votre application : utilisez le SDK OpenFeature avec le fournisseur flagd dans le code de votre application (qui s'exécute n'importe où : localement, sur site, dans un cloud autogéré). Configurez-le pour qu'il se connecte au service de flag App Lifecycle Manager (saasconfig.googleapis.com), s'authentifie et s'identifie à l'aide du nom de ressource Unit correspondant afin de récupérer les valeurs de flag appropriées.

Cette approche vous permet de bénéficier d'une distribution gérée et sécurisée des indicateurs sans modifier vos pipelines de déploiement ou vos outils de gestion d'infrastructure existants.

Les flags de fonctionnalité d'App Lifecycle Manager sont en preview privée. L'accès nécessite une liste d'autorisation. Pour demander l'accès pour votre organisation ou votre projet, remplissez ce formulaire.

Ce guide de démarrage rapide utilise une application Python de base exécutée localement pour montrer comment accéder aux flags, en simulant l'intégration de votre application existante.

Objectifs

Configurez un nouveau projet Google Cloud ou utilisez-en un existant.
Activez les API requises (App Lifecycle Manager et SaaS Config).
Accordez les autorisations IAM (Identity and Access Management) nécessaires pour créer des ressources et lire les options.
Créez des ressources App Lifecycle Manager minimales (offre d'application, type d'unité, unité) pour modéliser un composant d'application sans déployer d'infrastructure.
Définissez une ressource de flag de fonctionnalité associée au genre d'unité.
Créez un mécanisme de déploiement de flag (genre de déploiement) définissant la stratégie de distribution.
Distribuez la configuration initiale du flag à l'aide d'un déploiement App Lifecycle Manager.
Exécutez localement un exemple d'application Python qui se connecte au service de flag d'App Lifecycle Manager et évalue le flag pour l'unité modélisée.
Mettez à jour la valeur du flag, créez une version du flag et distribuez la modification.
Vérifiez que l'application récupère la valeur de l'option mise à jour.

Avant de commencer

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.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the App Lifecycle Manager and SaaS Config APIs, if any are not already enabled.
Roles required to enable APIs
To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.
Enable the APIs

Install the Google Cloud CLI.

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
Configure the gcloud CLI to use your federated identity.

For more information, see Sign in to the gcloud CLI with your federated identity.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
Installez Python : assurez-vous que Python 3.7 ou version ultérieure est installé sur la machine sur laquelle vous allez exécuter l'exemple d'application. Vous avez également besoin de pip pour installer les dépendances.
```
python --version
```
```
pip --version
```
Authentifiez gcloud pour les Identifiants par défaut de l'application (ADC) : le script Python local utilise les ADC pour s'authentifier auprès des services Google Cloud . Connectez-vous à votre compte utilisateur :
```
gcloud auth application-default login
```
Accorder des autorisations d'identité d'application : votre application doit être autorisée à lire les configurations de flag à partir du service SaaS Config. Attribuez le rôle "roles/saasconfig.viewer" à l'identité que l'application utilisera. Pour ce démarrage rapide, qui utilise ADC localement avec votre compte utilisateur, attribuez le rôle à votre adresse e-mail :
```
    gcloud projects add-iam-policy-binding PROJECT_ID \
        --member="user:YOUR_EMAIL_ADDRESS" \
        --role="roles/saasconfig.viewer"
```
Remplacez PROJECT_ID par l'ID de votre projet Google Cloud et YOUR_EMAIL_ADDRESS par l'adresse e-mail associée à votre connexion à la CLI.
Remarque : Dans un scénario de production, votre application exécutée sur Google Cloud ou ailleurs utiliserait généralement un compte de service dédié. Vous devez attribuer le rôle roles/saasconfig.viewer à ce compte de service plutôt qu'à votre compte utilisateur.

Créer des ressources App Lifecycle Manager minimales

Même si nous ne déployons pas d'infrastructure avec App Lifecycle Manager, nous avons besoin de quelques ressources pour organiser, cibler et distribuer nos flags de manière sécurisée. Ces ressources représentent vos composants d'application existants dans App Lifecycle Manager.

Définir des variables : définissez des variables d'environnement pour les noms et les emplacements des ressources.

export PROJECT_ID="your-project-id"
export SAAS_OFFERING_ID="standalone-flags-saas"
export UNIT_KIND_ID="standalone-app-kind"
export UNIT_ID="my-app-instance-01"
export LOCATION_1="us-central1" # Example region where your app instance conceptually resides
# Add more locations if your app components span multiple regions
# export LOCATION_2="europe-west1"

Créer une offre d'application : elle sert de conteneur de premier niveau pour la configuration de votre service, y compris les options.

gcloud beta app-lifecycle-manager saas create ${SAAS_OFFERING_ID} \
    --project=${PROJECT_ID} \
    --location=global \
    --locations=name=${LOCATION_1} # Add --locations=name=${LOCATION_2} if using more regions

 gcloud beta app-lifecycle-manager saas create ${SAAS_OFFERING_ID} \
    --project=${PROJECT_ID} \
    --location=${LOCATION_1} \
    --locations=name=${LOCATION_1}

Créer un genre d'unité : cela définit le type de composant que vous modélisez. Il est important de noter que nous ne fournissons pas de plan, car nous ne gérons pas l'infrastructure.

gcloud beta app-lifecycle-manager unit-kinds create ${UNIT_KIND_ID} \
  --project=${PROJECT_ID} \
  --location=global \
  --saas=${SAAS_OFFERING_ID}

gcloud beta app-lifecycle-manager unit-kinds create ${UNIT_KIND_ID} \
  --project=${PROJECT_ID} \
  --location=${LOCATION_1} \
  --saas=${SAAS_OFFERING_ID}

Créer une unité : cela représente une instance spécifique de votre application.

gcloud beta app-lifecycle-manager units create ${UNIT_ID} \
  --project=${PROJECT_ID} \
  --unit-kind=${UNIT_KIND_ID} \
  --location=${LOCATION_1}

Définir et déployer le flag de fonctionnalité

Créez maintenant le flag de fonctionnalité et utilisez le mécanisme de déploiement d'App Lifecycle Manager pour mettre sa configuration à la disposition des unités que vous avez créées.

Définissez les variables d'option :

export FLAG_ID="standalone-flag-01"
export FLAG_KEY="enable-beta-feature"

Créez la ressource, la révision et la version du flag :

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} \

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

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

Créer un type de déploiement : définissez la stratégie de distribution des modifications de flag.

export ROLLOUT_KIND_ID="standalone-flags-rollout-kind"

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éer le déploiement : lancez le processus de distribution.

export ROLLOUT_ID_1="${FLAG_ID}-rollout1"

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

Surveillez le déploiement : assurez-vous que le déploiement réussit avant de continuer.

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

Configurer une infrastructure autonome

Dans une configuration autonome, vous gérez votre propre hébergement d'applications (par exemple, Cloud Run ou GKE) et utilisez App Lifecycle Manager uniquement pour la synchronisation de la configuration. Le code de l'application reste standard d'un déploiement à l'autre. Il ne nécessite que la présence de la variable d'environnement FLAGD_SOURCE_PROVIDER_ID au moment de l'exécution pour se connecter au service de configuration SaaS.

Vous pouvez mapper vos définitions d'unités App Lifecycle Manager dans vos définitions de déploiement Terraform standards en transmettant le chemin d'accès construit en tant que variable d'environnement.

Définissez votre infrastructure : mappez le chemin d'accès dans votre modèle de déploiement (par exemple, standalone.tf).

variable "project_id" { type = string }
variable "region"     { type = string }
variable "unit_id"    { type = string }

resource "google_cloud_run_v2_service" "standalone_app" {
  name     = "my-standalone-service"
  location = var.region

  template {
    containers {
      image = "us-central1-docker.pkg.dev/my-project/my-repo/my-image:latest"

      env {
        name  = "FLAGD_SOURCE_PROVIDER_ID"
        value = "projects/${var.project_id}/locations/${var.region}/featureFlagsConfigs/${var.unit_id}"
      }
    }
  }
}

Définissez les valeurs de vos variables : fournissez les paramètres de l'unité de configuration dans un fichier de variables associé (par exemple, terraform.tfvars).
```
project_id = "PROJECT_ID"
region     = "LOCATION_1"
unit_id    = "UNIT_ID"
```

Intégrer et exécuter l'exemple d'application

Exécutez un exemple d'application Python localement pour vous connecter au service de flag App Lifecycle Manager à l'aide des configurations d'unité modélisées.

Créez le répertoire et les fichiers du projet :

mkdir saas_flags_standalone_app
cd saas_flags_standalone_app

Créez requirements.txt :

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

Installez les dépendances :

pip install -r requirements.txt

Créez app.py :

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.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

app = Flask(__name__)

logging.basicConfig(stream=sys.stdout, level=logging.INFO,
                    format='%(asctime)s - %(levelname)s - %(message)s')
log = logging.getLogger(__name__)

FLAG_KEY = os.environ.get("FLAG_KEY", "enable-beta-feature")
DEFAULT_FLAG_VALUE = False 

# CRITICAL: Read the Unit resource name from environment variable.
# This identifies the application instance to the flag service.
provider_id = os.environ.get("FLAGD_SOURCE_PROVIDER_ID")
if not provider_id:
    log.critical("FATAL: FLAGD_SOURCE_PROVIDER_ID not set.")
    sys.exit("FLAGD_SOURCE_PROVIDER_ID not set")

log.info(f"Initializing OpenFeature provider for Unit: {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:
    credentials, detected_project_id = google.auth.default(
        scopes=["https://www.googleapis.com/auth/cloud-platform"] 
    )
    auth_req = google.auth.transport.requests.Request() 

    configservice_credentials = grpc.composite_channel_credentials(
        grpc.ssl_channel_credentials(), 
        grpc.metadata_call_credentials( 
            google.auth.transport.grpc.AuthMetadataPlugin(credentials, auth_req)
        ),
        grpc.metadata_call_credentials(
            add_x_goog_request_params_header(provider_id)
        )
    )

    provider = FlagdProvider(
        resolver_type=ResolverType.IN_PROCESS,    
        host="saasconfig.googleapis.com",         
        port=443,                                 
        sync_metadata_disabled=True,              
        provider_id=provider_id,                  
        channel_credentials=configservice_credentials 
    )

    api.set_provider(provider)
    client = api.get_client()

    time.sleep(5)

    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)
    sys.exit(f"Provider initialization failed: {e}")

@app.route('/')
def home():
    log.info(f"Request received for endpoint '/', evaluating flag: {FLAG_KEY}")
    try:
        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,
            "provider_id": provider_id 
        })
    except Exception as e:
        log.error(f"Error evaluating flag '{FLAG_KEY}': {e}", exc_info=True)
        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 web server on host 0.0.0.0 port {port}")
    app.run(host='0.0.0.0', port=port)

Exécutez l'application :

export FLAGD_SOURCE_PROVIDER_ID="projects/${PROJECT_ID}/locations/${LOCATION_1}/featureFlagsConfigs/${UNIT_ID}"
python app.py

Vérifiez la valeur initiale de l'indicateur : exécutez une vérification sur le point de terminaison local dans un terminal secondaire.
```
curl http://localhost:8080
```

Mettre à jour l'indicateur et distribuer la modification

Modifiez l'état d'exécution de la définition de l'indicateur et distribuez la mise à jour aux cibles connectées.

Mettez à jour la ressource de flag :

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}

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

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

Créez un déploiement pour la mise à jour :

export ROLLOUT_ID_2="${FLAG_ID}-rollout2"

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

Surveillez le nouveau déploiement :

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

Vérifiez que la modification a bien été prise en compte dans l'application en cours d'exécution :
```
curl http://localhost:8080
```

Effectuer un nettoyage

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

Appuyez sur Ctrl+C dans le terminal où app.py est en cours d'exécution pour arrêter l'application Python locale.
Définissez l'état de l'indicateur.
Créez un déploiement pour supprimer les indicateurs obsolètes.

Une fois le déploiement terminé et les indicateurs obsolètes supprimés, supprimez les ressources App Lifecycle Manager :

gcloud beta app-lifecycle-manager rollouts delete ${ROLLOUT_ID_1} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager rollouts delete ${ROLLOUT_ID_2} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager rollout-kinds delete ${ROLLOUT_KIND_ID} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager flags releases delete ${FLAG_RELEASE_ID_1} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager flags releases delete ${FLAG_RELEASE_ID_2} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager flags delete ${FLAG_ID} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager units delete ${UNIT_ID} --project=${PROJECT_ID} --location=${LOCATION_1} --quiet 
gcloud beta app-lifecycle-manager unit-kinds delete ${UNIT_KIND_ID} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager unit-kinds delete ${UNIT_KIND_ID} --project=${PROJECT_ID} --location=${LOCATION_1} --quiet 
gcloud beta app-lifecycle-manager saas delete ${SAAS_OFFERING_ID} --project=${PROJECT_ID} --location=global --quiet 
gcloud beta app-lifecycle-manager saas delete ${SAAS_OFFERING_ID} --project=${PROJECT_ID} --location=${LOCATION_1} --quiet

Supprimez le répertoire local :
```
cd ..
rm -rf saas_flags_standalone_app
```

Étapes suivantes

Pour en savoir plus, consultez la présentation des flags de fonctionnalité d'App Lifecycle Manager.
Suivez le guide de démarrage rapide sur le déploiement de flags de fonctionnalité pour découvrir comment les flags s'intègrent étroitement aux déploiements gérés par App Lifecycle Manager.