App Lifecycle Manager-Funktions-Flags mit Go verwenden

In diesem Leitfaden wird erläutert, wie Sie Ihre Go-Anwendungen in die Funktions-Flags von App Lifecycle Manager einbinden. Sie erfahren, wie Sie das OpenFeature SDK mit dem flagd-Anbieter verwenden, um von App Lifecycle Manager verwaltete Flags auszuwerten. So können Sie die Verfügbarkeit und das Verhalten von Features in Ihren Go-Diensten dynamisch steuern.

In dieser Anleitung wird davon ausgegangen, dass Sie die erforderlichen App Lifecycle Manager-Ressourcen (z. B. SaaS-Angebote, Arten von Einheiten, Einheiten, Flags und Roll-outs) bereits eingerichtet haben, indem Sie eine der folgenden Kurzanleitungen durchgearbeitet haben:

Vorbereitung

Vor Beginn müssen folgende Voraussetzungen erfüllt sein:

  1. Go installiert: Version 1.23 oder höher.
  2. Kurzanleitung zu Funktions-Flags in App Lifecycle Manager abgeschlossen:
    • Sie haben entweder den integrierten oder den eigenständigen Schnellstart für Funktions-Flags erfolgreich abgeschlossen, um Ihre Zieleinheit bereitzustellen.
    • Sie sollten Umgebungsvariablen oder Werte aus dieser Kurzanleitung haben, z. B. PROJECT_ID, LOCATION_1 (die Region Ihrer Einheit), UNIT_ID und FLAG_KEY.
  3. Authentifizierte gcloud für Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC): Die Go-Anwendung verwendet ADC, um sich bei Google Cloud -Diensten zu authentifizieren. Wenn Sie die Anwendung lokal ausführen (für die eigenständige Verwendung oder lokale Docker-Tests), müssen Sie sich in Ihrer Umgebung authentifizieren:

    gcloud auth application-default login
    
  4. IAM-Berechtigungen: Die Identität, die Ihre Go-Anwendung ausführt, benötigt die IAM-Rolle (Identity and Access Management) roles/saasconfig.viewer für Ihr Google Cloud Projekt, um Flag-Konfigurationen zu lesen:

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

    Ersetzen Sie YOUR_PROJECT_ID und YOUR_EMAIL_ADDRESS entsprechend.

Wichtige Umgebungsvariablen kennenlernen

Ihre Go-Anwendung verwendet Umgebungsvariablen, um eine Verbindung zur richtigen Flag-Konfiguration herzustellen und das gewünschte Flag auszuwerten.

  • FLAGD_SOURCE_PROVIDER_ID: Gibt an, welche Funktions-Flag-Konfiguration vom App Lifecycle Manager-Dienst abgerufen werden soll. Es muss der vollständige Ressourcenname des FeatureFlagConfig sein, der mit Ihrer Einheit verknüpft ist.
    • Format: projects/PROJECT_ID/locations/LOCATION/featureFlagsConfigs/UNIT_ID
    • Beispiel: projects/my-gcp-project/locations/us-central1/featureFlagsConfigs/my-app-instance-01

Go-Projekt einrichten

Bevor Sie Ihre Anwendung ausführen können, müssen Sie Ihr Modul initialisieren und die erforderliche Initialisierungs- und Bewertungslogik hinzufügen.

  1. Erstellen Sie ein Projektverzeichnis:

    mkdir go-featureflag-app
    cd go-featureflag-app
    go mod init go-featureflag-app
    
  2. Anwendungscode erstellen: Fügen Sie eine Datei mit dem Namen main.go und dem folgenden Inhalt hinzu, um den Anbieter zu initialisieren und ein Flag auszuwerten.

    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. go.mod erstellen: Die Verwendung bestimmter Versionen sorgt für Stabilität.

    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. Abhängigkeiten abrufen:

    go mod tidy
    go mod download
    

Go-Anwendung ausführen

Sie können die Anwendung entweder lokal mit Ihrer eigenständigen Konfiguration oder als Container bereitgestellt ausführen.

Eigenständig (lokal) ausführen

  1. Umgebungsvariablen festlegen:

    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. Führen Sie die Anwendung aus:

    go run main.go
    

Integriert ausführen (containerisiert)

  1. Dockerfile erstellen:

    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. Erstellen Sie das Image und übertragen Sie es per Push:

    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. Dienst bereitstellen: Aktualisieren Sie Ihren Einheiten-Blueprint, um auf gcr.io/${PROJECT_ID}/my-go-app:latest zu verweisen, und stellen Sie den neuen Release mit einem App Lifecycle Manager-Roll-out bereit.

Flag-Änderungen prüfen

Prüfen Sie nach dem Start der Anwendung, ob die Flags korrekt ausgewertet werden.

  1. Anfangswert beobachten: Prüfen Sie, ob in der Ausgabe der Wert für den Anfangszustand protokolliert wird.
  2. Flag im App Lifecycle Manager aktualisieren: Ändern Sie das Flag-Verhalten mit der Google Cloud Console oder gcloud.
  3. Aktualisierten Wert prüfen: Führen Sie die lokale Kompilierung noch einmal aus oder sehen Sie sich die Containerlogs an, um das aktualisierte Ergebnis zu sehen.

Nächste Schritte