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:
- Kurzanleitung: Funktions-Flags mit App Lifecycle Manager (integriert) bereitstellen: Wenn Sie Ihre Anwendungsbereitstellungen mit App Lifecycle Manager verwalten.
- Kurzanleitung: Funktions-Flags eigenständig verwenden: Wenn Sie Ihre Anwendungsinfrastruktur unabhängig verwalten, aber App Lifecycle Manager für die Verwaltung von Funktions-Flags verwenden möchten.
Vorbereitung
Vor Beginn müssen folgende Voraussetzungen erfüllt sein:
- Go installiert: Version 1.23 oder höher.
- 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_IDundFLAG_KEY.
Authentifizierte
gcloudfü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 loginIAM-Berechtigungen: Die Identität, die Ihre Go-Anwendung ausführt, benötigt die IAM-Rolle (Identity and Access Management)
roles/saasconfig.viewerfü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_IDundYOUR_EMAIL_ADDRESSentsprechend.
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 desFeatureFlagConfigsein, 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
- Format:
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.
Erstellen Sie ein Projektverzeichnis:
mkdir go-featureflag-app cd go-featureflag-app go mod init go-featureflag-appAnwendungscode erstellen: Fügen Sie eine Datei mit dem Namen
main.gound 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.") } }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 )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
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}"Führen Sie die Anwendung aus:
go run main.go
Integriert ausführen (containerisiert)
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"]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:latestDienst bereitstellen: Aktualisieren Sie Ihren Einheiten-Blueprint, um auf
gcr.io/${PROJECT_ID}/my-go-app:latestzu 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.
- Anfangswert beobachten: Prüfen Sie, ob in der Ausgabe der Wert für den Anfangszustand protokolliert wird.
- Flag im App Lifecycle Manager aktualisieren: Ändern Sie das Flag-Verhalten mit der Google Cloud Console oder
gcloud. - 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
- Weitere konzeptionelle Details finden Sie in der Übersicht über Funktions-Flags in App Lifecycle Manager.
- Informationen zu App Lifecycle Manager-Roll-outs für sicherere Flag-Bereitstellungen
- Lesen Sie die Übersicht zu App Lifecycle Manager.