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 :
- Guide de démarrage rapide : Déployer des flags de fonctionnalité avec App Lifecycle Manager (intégré) : si vous gérez les déploiements de votre application avec App Lifecycle Manager.
- Guide de démarrage rapide : Utiliser les flags de fonctionnalité de manière autonome : si vous gérez l'infrastructure de votre application de manière indépendante, mais que vous souhaitez utiliser App Lifecycle Manager pour la gestion des flags de fonctionnalité.
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
- Go installé : version 1.23 ou ultérieure.
- 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_IDetFLAG_KEY.
gcloudauthentifié 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 loginAutorisations IAM : l'identité qui exécute votre application Go doit disposer du rôle Identity and Access Management
roles/saasconfig.viewersur 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_IDetYOUR_EMAIL_ADDRESSen 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 ressourceFeatureFlagConfigassocié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
- Format :
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.
Créez un répertoire de projet :
mkdir go-featureflag-app cd go-featureflag-app go mod init go-featureflag-appCréer le code de l'application : ajoutez un fichier nommé
main.goavec 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.") } }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 )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)
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}"Exécutez l'application :
go run main.go
Exécuter de manière intégrée (conteneurisée)
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"]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:latestDéployer le service : mettez à jour le plan de votre unité pour référencer
gcr.io/${PROJECT_ID}/my-go-app:latestet 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.
- Observez la valeur initiale : vérifiez que le résultat consigne la valeur correspondant à l'état initial.
- Mettre à jour le flag dans App Lifecycle Manager : modifiez le comportement du flag à l'aide de la console Google Cloud ou de
gcloud. - 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
- Pour en savoir plus, consultez la présentation des flags de fonctionnalité App Lifecycle Manager.
- Découvrez les déploiements App Lifecycle Manager pour des déploiements de flags plus sûrs.
- Consultez la présentation principale d'App Lifecycle Manager.