Utilizzare i flag funzionalità di App Lifecycle Manager con Go

Questa guida spiega come integrare le applicazioni Go con i flag delle funzionalità di App Lifecycle Manager. Scoprirai come utilizzare l'SDK OpenFeature con il provider flagd per valutare i flag gestiti da App Lifecycle Manager, consentendoti di controllare dinamicamente la disponibilità e il comportamento delle funzionalità nei tuoi servizi Go.

Questa guida presuppone che tu abbia già configurato le risorse di App Lifecycle Manager necessarie (come le offerte SaaS, i tipi di unità, le unità, i flag e i rollout) completando una delle seguenti guide rapide:

Prerequisiti

Prima di iniziare, assicurati di avere quanto segue:

  1. Go installato: versione 1.23 o successive.
  2. Completamento di una guida rapida ai flag delle funzionalità di App Lifecycle Manager:
    • Hai completato correttamente la guida rapida ai flag delle funzionalità integrata o autonoma per eseguire il provisioning dell'unità di destinazione.
    • Dovresti avere variabili o valori di ambiente da questa guida rapida, come PROJECT_ID, LOCATION_1 (la regione dell'unità), UNIT_ID e FLAG_KEY.

  3. Autenticazione di gcloud per le Credenziali predefinite dell'applicazione (ADC): l'applicazione Go utilizza ADC per l'autenticazione con i Google Cloud servizi. Se esegui l'applicazione in locale (per l'utilizzo autonomo o per i test Docker locali), assicurati di aver eseguito l'autenticazione nel tuo ambiente:

    gcloud auth application-default login

  4. Autorizzazioni IAM: l'identità che esegue l'applicazione Go deve disporre del ruolo roles/saasconfig.viewer Identity and Access Management nel Google Cloud progetto per leggere le configurazioni dei flag:

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

    Sostituisci YOUR_PROJECT_ID e YOUR_EMAIL_ADDRESS di conseguenza.

Informazioni sulle variabili di ambiente chiave

L'applicazione Go si basa sulle variabili di ambiente per connettersi alla configurazione dei flag corretta e valutare il flag previsto.

  • FLAGD_SOURCE_PROVIDER_ID: specifica la configurazione flag funzionalità da recuperare dal servizio App Lifecycle Manager. Deve essere il nome completo della risorsa FeatureFlagConfig associata all'unità.
    • Formato: projects/PROJECT_ID/locations/LOCATION/featureFlagsConfigs/UNIT_ID
    • Esempio: projects/my-gcp-project/locations/us-central1/featureFlagsConfigs/my-app-instance-01

Configurare il progetto Go

Prima di poter eseguire l'applicazione, inizializza il modulo e aggiungi la logica di inizializzazione e valutazione necessaria.

  1. Crea una directory di progetto:

    mkdir go-featureflag-app
cd go-featureflag-app
go mod init go-featureflag-app

  2. Crea il codice dell'applicazione: aggiungi un file denominato main.go con il seguente contenuto per inizializzare il provider e valutare 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.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. Crea go.mod: l'utilizzo di versioni specifiche garantisce 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. Scarica le dipendenze:

    go mod tidy
go mod download

Eseguire l'applicazione Go

Puoi eseguire l'applicazione in locale utilizzando la configurazione autonoma o di cui è stato eseguito il deployment come container.

Eseguire in modalità autonoma (in locale)

  1. Imposta le variabili di ambiente:

    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. Esegui l'applicazione:

    go run main.go

Eseguire in modalità integrata (containerizzata)

  1. Crea un 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. Crea ed esegui il push dell'immagine:

    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. Esegui il deployment del servizio: aggiorna il progetto dell'unità in modo che faccia riferimento a gcr.io/${PROJECT_ID}/my-go-app:latest ed esegui il deployment della nuova release utilizzando un rollout di App Lifecycle Manager.

Verificare le modifiche dei flag

Dopo aver eseguito l'applicazione, verifica che valuti correttamente i flag.

  1. Osserva il valore iniziale: verifica che l'output registri il valore corrispondente allo stato iniziale.
  2. Aggiorna il flag in App Lifecycle Manager: modifica il comportamento del flag utilizzando la Google Cloud console o gcloud.
  3. Verifica il valore aggiornato: esegui di nuovo la compilazione locale o osserva i log dei container per visualizzare il risultato aggiornato.

Passaggi successivi