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.

Utiliser des flags de fonctionnalité dans Standalone

Découvrez comment utiliser les indicateurs de fonctionnalité App Lifecycle Manager en tant que service autonome pour gérer la disponibilité des fonctionnalités dans vos applications, même si celles-ci 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 signalisation de fonctionnalité et de déploiement contrôlé d'App Lifecycle Manager sans avoir à utiliser App Lifecycle Manager pour le provisionnement d'infrastructure (comme le déploiement de VM ou de services Cloud Run à l'aide de blueprints Terraform). Cette approche est idéale si vous gérez votre infrastructure d'application de manière indépendante, mais que vous souhaitez utiliser App Lifecycle Manager pour gérer les feature flags 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 ou une instance binaire unique). Ces unités servent uniquement de cibles pour les configurations de flag et n'impliquent pas le déploiement d'une infrastructure à l'aide de plans App Lifecycle Manager.
Définir et distribuer des indicateurs : utilisez l'API App Lifecycle Manager ou la console Google Cloud pour créer des indicateurs 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 à vos Units modélisés. Cela permet d'assurer la cohérence et la sécurité opérationnelles, même lorsque vous ne gérez que des indicateurs.
Intégration à votre application : utilisez le SDK OpenFeature avec le fournisseur flagd dans le code de votre application (exécuté n'importe où : localement, sur site ou 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 pour récupérer les valeurs de flag correctes.

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 ni vos outils de gestion de l'infrastructure existants.

Les indicateurs de fonctionnalité 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 en local pour montrer comment accéder aux indicateurs, en simulant l'intégration de votre application existante.

Objectifs

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

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

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

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

Installez Python : assurez-vous que Python 3.7 ou version ultérieure est installé sur la machine sur laquelle vous exécuterez l'application exemple. 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é à l'application : votre application a besoin d'une autorisation pour lire les configurations de l'indicateur à partir du service de configuration SaaS. Attribuez le rôle `roles/saasconfig.viewer` à l'identité que l'application utilisera. Pour ce guide de démarrage rapide utilisant ADC en local avec votre compte utilisateur, accordez 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 identifiant de connexion à la CLI.
Remarque : Dans un scénario de production, votre application s'exécutant 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 au lieu de 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 indicateurs de manière sécurisée. Ces ressources représentent les composants existants de votre application dans App Lifecycle Manager.

Définissez 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éez une offre SaaS : elle sert de conteneur de premier niveau pour la configuration de votre service, y compris les indicateurs.

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éez 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é : il s'agit d'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 App Lifecycle Manager pour rendre sa configuration disponible pour les unités que vous avez créées.

Définissez les variables d'indicateur :

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éez un type de déploiement : définissez la stratégie de distribution des modifications apportées aux indicateurs.

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éez 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 a réussi 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'application (par exemple, Cloud Run ou GKE) et utilisez App Lifecycle Manager uniquement pour la synchronisation de la configuration. Le code d'application reste standard pour tous les déploiements. Il nécessite uniquement 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 en local pour vous connecter au service de flag App Lifecycle Manager à l'aide des configurations d'unités 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 du signalement : exécutez une vérification par rapport au point de terminaison local dans un terminal secondaire.
```
curl http://localhost:8080
```

Mettre à jour le flag et distribuer la modification

Modifiez l'état d'exécution de la définition du flag 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 la modification 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 anciens indicateurs.

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 sur les concepts, consultez Présentation des indicateurs de fonctionnalité App Lifecycle Manager.
Essayez le guide de démarrage rapide sur le déploiement des feature flags pour découvrir comment les flags s'intègrent étroitement aux déploiements gérés par App Lifecycle Manager.