Usar flags de recursos do App Lifecycle Manager com Go

Este guia explica como integrar seus aplicativos Go com flags de recursos do App Lifecycle Manager. Você vai aprender a usar o SDK OpenFeature com o provedor flagd para avaliar flags gerenciadas pelo App Lifecycle Manager, permitindo controlar dinamicamente a disponibilidade de recursos e o comportamento nos seus serviços Go.

Este guia pressupõe que você já configurou os recursos necessários do App Lifecycle Manager (como ofertas de SaaS, tipos de unidades, unidades, flags e lançamentos) ao concluir um dos seguintes quickstarts:

Pré-requisitos

Antes de começar, verifique se você tem o seguinte:

  1. Go instalado:versão 1.23 ou mais recente.
  2. Conclua um guia de início rápido de flags de recursos do App Lifecycle Manager:
    • Conclua com sucesso o guia de início rápido das flags de recurso integradas ou autônomas para provisionar sua unidade de destino.
    • Você precisa ter variáveis de ambiente ou valores desse início rápido, como PROJECT_ID, LOCATION_1 (a região da sua unidade), UNIT_ID e FLAG_KEY.

  3. gcloud autenticado para Application Default Credentials (ADC): o aplicativo Go usa o ADC para autenticar com os serviços Google Cloud . Se você estiver executando localmente (para uso independente ou teste local do Docker), verifique se fez a autenticação no seu ambiente:

    gcloud auth application-default login

  4. Permissões do IAM:a identidade que executa seu aplicativo Go precisa da função roles/saasconfig.viewer do Identity and Access Management no projeto Google Cloud para ler as configurações de flag:

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

    Substitua YOUR_PROJECT_ID e YOUR_EMAIL_ADDRESS de acordo com a situação.

Entender as principais variáveis de ambiente

Seu aplicativo Go depende de variáveis de ambiente para se conectar à configuração de flag correta e avaliar a flag pretendida.

  • FLAGD_SOURCE_PROVIDER_ID: especifica qual configuração de flag de recurso buscar no serviço do App Lifecycle Manager. Ele precisa ser o nome completo do recurso do FeatureFlagConfig associado à sua unidade.
    • Formato: projects/PROJECT_ID/locations/LOCATION/featureFlagsConfigs/UNIT_ID
    • Exemplo: projects/my-gcp-project/locations/us-central1/featureFlagsConfigs/my-app-instance-01

Configurar o projeto Go

Antes de executar o aplicativo, inicialize o módulo e adicione a lógica de inicialização e avaliação necessária.

  1. Crie um diretório de projeto:

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

  2. Criar código do aplicativo:adicione um arquivo chamado main.go com o seguinte conteúdo para inicializar o provedor e avaliar uma 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. Criar go.mod:usar versões específicas garante a estabilidade.

    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. Receber dependências:

    go mod tidy
go mod download

Executar o aplicativo Go

Você pode executar o aplicativo localmente usando sua configuração independente ou implantado como um contêiner.

Executar independente (localmente)

  1. Defina variáveis de 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. Execute o aplicativo:

    go run main.go

Executar integrado (em contêiner)

  1. Crie um 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. Crie e envie a imagem:

    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. Implante o serviço:atualize o blueprint da unidade para referenciar gcr.io/${PROJECT_ID}/my-go-app:latest e implante a nova versão usando um lançamento do App Lifecycle Manager.

Verificar mudanças de flag

Depois que o aplicativo estiver em execução, confirme se ele avalia as flags corretamente.

  1. Observe o valor inicial:verifique se a saída registra o valor correspondente ao estado inicial.
  2. Atualize a flag no App Lifecycle Manager:modifique o comportamento da flag usando o console Google Cloud ou gcloud.
  3. Verifique o valor atualizado:execute novamente a compilação local ou observe os registros do contêiner para conferir o resultado atualizado.

A seguir