App Lifecycle Manager-Funktions-Flags mit Go verwenden

In dieser Anleitung wird beschrieben, wie Sie Ihre Go-Anwendungen in App Lifecycle Manager-Funktions-Flags einbinden. Sie erfahren, wie Sie das OpenFeature SDK mit dem flagd-Anbieter verwenden, um Flags auszuwerten, die von App Lifecycle Manager verwaltet werden. So können Sie die Verfügbarkeit und das Verhalten von Funktionen in Ihren Go-Diensten dynamisch steuern.

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

Vorbereitung

Prüfen Sie vor Beginn, ob Sie Folgendes haben:

  1. Go installiert:Version 1.23 oder höher.
  2. Kurzanleitung zu App Lifecycle Manager-Funktions-Flags durchgearbeitet:
    • Sie haben entweder die integrierte oder die eigenständige Kurzanleitung zu Funktions-Flags erfolgreich durchgearbeitet, 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. Authentifiziert gcloud für Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC): Die Go-Anwendung verwendet ADC zur Authentifizierung bei Google Cloud Diensten. Wenn Sie lokal arbeiten (für die eigenständige Verwendung oder lokale Docker-Tests), müssen Sie sich in Ihrer Umgebung authentifiziert haben:

    gcloud auth application-default login

  4. IAM-Berechtigungen:Die Identität, mit der Ihre Go-Anwendung ausgeführt wird, benötigt die roles/saasconfig.viewer Identity and Access Management-Rolle für Ihr Google Cloud Projekt, um Flag-Konfigurationen lesen zu können:

    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

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 der FeatureFlagConfig sein, die 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 Auswertungslogik hinzufügen.

  1. Projektverzeichnis erstellen :

    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 mit folgendem 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.NewEvaluationContext()

// 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 ausführen (lokal)

  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. Anwendung ausführen :

    go run main.go

Integriert ausführen (Container)

  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. Image erstellen und per Push übertragen :

    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 die Neuveröffentlichung mit einem App Lifecycle Manager-Roll-out bereit.

Flag-Änderungen prüfen

Nachdem Ihre Anwendung ausgeführt wird, prüfen Sie, ob Flags korrekt ausgewertet werden.

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

Nächste Schritte