Utiliser les commutateurs de fonctionnalité App Lifecycle Manager avec Go

Ce guide explique comment intégrer vos applications Go aux flags de fonctionnalité d'App Lifecycle Manager. Vous allez apprendre à utiliser le SDK OpenFeature avec le fournisseur flagd pour évaluer les flags gérés par App Lifecycle Manager, ce qui vous permettra de contrôler de manière dynamique la disponibilité et le comportement des fonctionnalités dans vos services Go.

Ce guide suppose que vous avez déjà configuré les ressources App Lifecycle Manager nécessaires (comme les offres SaaS, les genres d'unité, les unités, les flags et les déploiements) en suivant l'un des guides de démarrage rapide suivants :

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

  1. Go installé : version 1.23 ou ultérieure.
  2. Vous avez suivi un guide de démarrage rapide sur les flags de fonctionnalité App Lifecycle Manager :
    • Vous avez suivi le guide de démarrage rapide sur les flags de fonctionnalité intégrés ou autonomes pour provisionner votre unité cible.
    • Vous devriez disposer de variables d'environnement ou de valeurs issues de ce guide de démarrage rapide, telles que PROJECT_ID, LOCATION_1 (la région de votre unité), UNIT_ID et FLAG_KEY.
  3. gcloud authentifié pour les Identifiants par défaut de l'application (ADC) : l'application Go utilise les ADC pour s'authentifier auprès des services Google Cloud . Si vous exécutez le code localement (pour une utilisation autonome ou des tests Docker locaux), assurez-vous de vous être authentifié dans votre environnement :

    gcloud auth application-default login
    
  4. Autorisations IAM : l'identité qui exécute votre application Go doit disposer du rôle Identity and Access Management roles/saasconfig.viewer sur votre projet Google Cloud pour lire les configurations de flag :

    gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
        --member="user:YOUR_EMAIL_ADDRESS" \
        --role="roles/saasconfig.viewer"
    

    Remplacez YOUR_PROJECT_ID et YOUR_EMAIL_ADDRESS en conséquence.

Comprendre les principales variables d'environnement

Votre application Go s'appuie sur des variables d'environnement pour se connecter à la configuration de flag appropriée et évaluer le flag prévu.

  • FLAGD_SOURCE_PROVIDER_ID : spécifie la configuration de flag de fonctionnalité à récupérer depuis le service App Lifecycle Manager. Il doit s'agir du nom complet de la ressource FeatureFlagConfig associée à votre unité.
    • Format : projects/PROJECT_ID/locations/LOCATION/featureFlagsConfigs/UNIT_ID
    • Exemple : projects/my-gcp-project/locations/us-central1/featureFlagsConfigs/my-app-instance-01

Configurer votre projet Go

Avant de pouvoir exécuter votre application, initialisez votre module, puis ajoutez la logique d'initialisation et d'évaluation nécessaire.

  1. Créez un répertoire de projet :

    mkdir go-featureflag-app
    cd go-featureflag-app
    go mod init go-featureflag-app
    
  2. Créer le code de l'application : ajoutez un fichier nommé main.go avec le contenu suivant pour initialiser le fournisseur et évaluer un flag.

    package main
    
    import (
        "context"
        "fmt"
        "log"
        "os"
    
        flagd "github.com/open-feature/go-sdk-contrib/providers/flagd/pkg"
        "github.com/open-feature/go-sdk/openfeature"
        "google.golang.org/grpc"
        "google.golang.org/grpc/credentials"
        "google.golang.org/grpc/credentials/oauth"
        "google.golang.org/grpc/metadata"
    )
    
    // GetNewFlagdProvider initializes a flagd provider configured for  App Lifecycle Manager
    func GetNewFlagdProvider(ctx context.Context) (*flagd.Provider, error) {
        providerID := os.Getenv("FLAGD_SOURCE_PROVIDER_ID")
        if providerID == "" {
            return nil, fmt.Errorf("FLAGD_SOURCE_PROVIDER_ID environment variable is not set")
        }
    
        creds, err := oauth.NewApplicationDefault(ctx)
        if err != nil {
            return nil, err
        }
    
        // Interceptor to inject the Unit name into headers for regional routing
        routingInterceptor := func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
            md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("name=%s", providerID))
            ctx = metadata.NewOutgoingContext(ctx, md)
            return streamer(ctx, desc, cc, method, opts...)
        }
    
        options := []flagd.ProviderOption{
            flagd.WithHost("saasconfig.googleapis.com"),
            flagd.WithPort(443),
            flagd.WithInProcessResolver(),
            flagd.WithProviderID(providerID),
            flagd.WithGrpcDialOptionsOverride([]grpc.DialOption{
                grpc.WithTransportCredentials(credentials.NewTLS(nil)),
                grpc.WithPerRPCCredentials(creds),
                grpc.WithStreamInterceptor(routingInterceptor),
            }),
        }
    
        return flagd.NewProvider(options...)
    }
    
    // InitializeFeatureManagement registers the provider globally
    func InitializeFeatureManagement(ctx context.Context) error {
        provider, err := GetNewFlagdProvider(ctx)
        if err != nil {
            return err
        }
        openfeature.SetProvider(provider)
        return nil
    }
    
    func main() {
    ctx := context.Background()
    InitializeFeatureManagement(ctx);
    
    // 1. Get Client
    client := openfeature.NewClient("simple-api")
    
    // 2. Create Evaluation Context
    evalCtx := openfeature.EvaluationContext{}
    
    // 3. Evaluate Flag
    // Default to false if evaluation fails
    isEnhanced, err := client.BooleanValue(context.Background(), "enhanced-search", false, evalCtx)
    if err != nil {
    log.Printf("Flag evaluation failed: %v", err)
    }
    
    // 4. Return response
    if isEnhanced {
    fmt.Println("Enhanced search feature is enabled.")
    } else {
    fmt.Println("Enhanced search feature is disabled.")
    }
    
    }
    
  3. Créer go.mod : l'utilisation de versions spécifiques garantit la stabilité.

    module go-featureflag-app
    
    go 1.23
    
    require (
        github.com/open-feature/go-sdk v1.15.1
        github.com/open-feature/go-sdk-contrib/providers/flagd v0.3.0
        google.golang.org/grpc v1.74.2
        golang.org/x/oauth2 v0.22.0
    )
    
  4. Obtenez les dépendances :

    go mod tidy
    go mod download
    

Exécuter l'application Go

Vous pouvez exécuter l'application localement à l'aide de votre configuration autonome ou la déployer en tant que conteneur.

Exécuter de manière autonome (localement)

  1. Définissez les variables d'environnement :

    export PROJECT_ID="your-gcp-project-id"
    export LOCATION_1="us-central1"
    export UNIT_ID="my-app-instance-01"
    export FLAGD_SOURCE_PROVIDER_ID="projects/${PROJECT_ID}/locations/${LOCATION_1}/featureFlagsConfigs/${UNIT_ID}"
    
  2. Exécutez l'application :

    go run main.go
    

Exécuter de manière intégrée (conteneurisée)

  1. Créez un fichier Dockerfile :

    FROM golang:1.23 as builder
    WORKDIR /app
    COPY go.mod go.sum ./
    RUN go mod download
    COPY . .
    RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /go-featureflag-app .
    
    FROM gcr.io/distroless/static-debian11
    WORKDIR /
    COPY --from=builder /go-featureflag-app /go-featureflag-app
    ENTRYPOINT ["/go-featureflag-app"]
    
  2. Créez et transférez l'image :

    export PROJECT_ID="your-gcp-project-id"
    docker build -t gcr.io/${PROJECT_ID}/my-go-app:latest .
    docker push gcr.io/${PROJECT_ID}/my-go-app:latest
    
  3. Déployer le service : mettez à jour le plan de votre unité pour référencer gcr.io/${PROJECT_ID}/my-go-app:latest et déployez la nouvelle version à l'aide d'un déploiement App Lifecycle Manager.

Vérifier les modifications apportées aux options

Une fois votre application en cours d'exécution, vérifiez qu'elle évalue correctement les indicateurs.

  1. Observez la valeur initiale : vérifiez que le résultat consigne la valeur correspondant à l'état initial.
  2. Mettre à jour le flag dans App Lifecycle Manager : modifiez le comportement du flag à l'aide de la console Google Cloud ou de gcloud.
  3. Vérifiez la valeur mise à jour : relancez la compilation locale ou observez les journaux du conteneur pour voir le résultat mis à jour.

Étapes suivantes