Utilizzare i flag funzionalità di App Lifecycle Manager con Java

Questa guida spiega come integrare le applicazioni Java con i flag di 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 Java.

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

Prerequisiti

Prima di iniziare, assicurati di avere quanto segue:

  1. Java installato: JDK 17 o versioni 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 Java utilizza ADC per l'autenticazione con i Google Cloud servizi. Assicurati di aver eseguito l'autenticazione nel tuo ambiente:

    gcloud auth application-default login

  4. Autorizzazioni IAM: l'identità che esegue l'applicazione Java 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 Java si basa sulle variabili di ambiente per connettersi alla configurazione dei flag corretta.

  • 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 Java

Prima di poter eseguire l'applicazione, devi inizializzare il progetto e configurare le dipendenze necessarie.

  1. Crea una directory di progetto:

    mkdir java-featureflag-app
cd java-featureflag-app

  2. Aggiungi dipendenze: configura il sistema di compilazione (Maven o Gradle) in modo da includere le seguenti librerie. Per garantire la compatibilità, utilizza versioni successive a OpenFeature 1.14.1, flagd 0.11.5 e gRPC 1.71.0.

    • dev.openfeature:javasdk:1.14.1+
    • dev.openfeature.contrib.providers:flagd:0.11.5+
    • io.grpc:grpc-netty-shaded:1.71.0+
    • io.grpc:grpc-auth:1.71.0+
    • com.google.auth:google-auth-library-oauth2-http

  3. Crea il codice di inizializzazione: aggiungi un file denominato FeatureManagement.java con il seguente contenuto. Questa classe configura gli intercettori gRPC per collegare le intestazioni ADC e di routing regionale e inizializza FlagdProvider utilizzando la risoluzione in-process.

    import com.google.auth.oauth2.GoogleCredentials;
import dev.openfeature.contrib.providers.flagd.Config;
import dev.openfeature.contrib.providers.flagd.FlagdOptions;
import dev.openfeature.contrib.providers.flagd.FlagdProvider;
import dev.openfeature.sdk.OpenFeatureAPI;
import io.grpc.*;
import io.grpc.auth.MoreCallCredentials;
import java.util.ArrayList;
import java.util.List;

public class FeatureManagement {
    public static void initialize() throws Exception {
        // Read the full Unit resource name
        String flagConfigId = System.getenv("FLAGD_SOURCE_PROVIDER_ID");
        if (flagConfigId == null || flagConfigId.isEmpty()) {
            throw new IllegalStateException("FLAGD_SOURCE_PROVIDER_ID environment variable is not set.");
        }

        // Configure gRPC Security and Routing
        GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
        CallCredentials callCredentials = MoreCallCredentials.from(credentials);

        List<ClientInterceptor> interceptors = new ArrayList<>();

        // Interceptor to inject the Unit name into headers for regional routing
        interceptors.add(new ClientInterceptor() {
            @Override
            public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
                return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
                    @Override
                    public void start(Listener<RespT> responseListener, Metadata headers) {
                        headers.put(Metadata.Key.of("x-goog-request-params", Metadata.ASCII_STRING_MARSHALLER), "name=" + flagConfigId);
                        super.start(responseListener, headers);
                    }
                };
            }
        });

        // Interceptor to attach ADC to the gRPC calls
        interceptors.add(new ClientInterceptor() {
            @Override
            public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
                return next.newCall(method, callOptions.withCallCredentials(callCredentials));
            }
        });

        // Initialize the flagd provider with In-Process resolution
        FlagdProvider provider = new FlagdProvider(
            FlagdOptions.builder()
                .resolverType(Config.Resolver.IN_PROCESS)
                .host("saasconfig.googleapis.com").port(443)
                .tls(true)
                .providerId(flagConfigId)
                .clientInterceptors(interceptors)
                .syncMetadataDisabled(true)
                .deadline(10000)
                .build()
        );

        // Set the global provider
        OpenFeatureAPI.getInstance().setProviderAndWait(provider);
    }
}

  4. Crea la logica dell'applicazione: aggiungi un file denominato Main.java con il seguente contenuto per eseguire la valutazione dei flag.

    import dev.openfeature.sdk.OpenFeatureAPI;
import dev.openfeature.sdk.MutableContext;

public class Main {
    public static void main(String[] args) throws Exception {

    // 1. Get Client
    var client = OpenFeatureAPI.getInstance().getClient("simple-api");

    // 2. Create Evaluation Context 
    var context = new dev.openfeature.sdk.MutableContext();

    // 3. Evaluate Flag
    // Default to false if evaluation fails or service is unreachable
    boolean isEnhanced = client.getBooleanValue("enhanced-search", false, context);

    // 4. Execute business logic based on result
    if (isEnhanced) {
        System.out.println("Executing enhanced search algorithm...");
    } else {
        System.out.println("Standard search algorithm...");
    }

    }
}

Eseguire l'applicazione Java

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

Eseguire in modalità autonoma (localmente)

  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: esegui il progetto utilizzando il comando dello strumento di build che preferisci (ad es. mvn compile exec:java o ./gradlew run).

Eseguire in modalità integrata (containerizzata)

  1. Crea un Dockerfile: definisci una build del container che includa il file binario Java.

    FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package

FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=builder /app/target/java-featureflag-app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

  2. Crea e push dell'immagine:

    export PROJECT_ID="your-gcp-project-id"
docker build -t gcr.io/${PROJECT_ID}/my-java-app:latest .
docker push gcr.io/${PROJECT_ID}/my-java-app:latest

  3. Esegui il deployment del servizio: aggiorna il progetto dell'unità in modo che faccia riferimento a gcr.io/${PROJECT_ID}/my-java-app:latest ed esegui il deployment della nuova release utilizzando un'implementazione 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 della console registri il valore valutato corrispondente allo stato di configurazione iniziale.
  2. Aggiorna il flag in App Lifecycle Manager: modifica il payload del flag o le regole di targeting utilizzando la console o Google Cloud gcloud.
  3. Verifica il valore aggiornato: esegui di nuovo l'esecuzione locale o osserva i log dei container per verificare il nuovo stato valutato.

Passaggi successivi