Men-deploy tombol fitur

Panduan memulai ini menunjukkan cara membuat, meluncurkan, dan menggunakan tombol fitur dengan App Lifecycle Manager.

Dalam panduan memulai ini, Anda akan mempelajari cara menginstal dan mengonfigurasi penyedia tombol, serta melakukan pemberian tombol fitur dasar menggunakan tombol fitur App Lifecycle Manager.

Sebelum memulai

  1. Login ke Akun Google Anda.

    Jika Anda belum memilikinya, Daftar untuk membuat akun baru.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the App Lifecycle Manager, Artifact Registry, Infrastructure Manager, Developer Connect, Cloud Build, Cloud Storage, Cloud Run and SaaS Config APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. Create a service account:

    1. Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator) and the Project IAM Admin role (roles/resourcemanager.projectIamAdmin). Learn how to grant roles.

    2. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
    3. Select your project.

    4. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

    5. Click Create and continue.

    6. Grant the Project > Owner role to the service account.

      To grant the role, find the Select a role list, then select Project > Owner.

    7. Click Continue.

    8. Click Done to finish creating the service account.

  6. Instal Google Cloud CLI.

  7. Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

  8. Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut: 

    gcloud init

  9. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  10. Verify that billing is enabled for your Google Cloud project.

  11. Enable the App Lifecycle Manager, Artifact Registry, Infrastructure Manager, Developer Connect, Cloud Build, Cloud Storage, Cloud Run and SaaS Config APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  12. Create a service account:

    1. Ensure that you have the Create Service Accounts IAM role (roles/iam.serviceAccountCreator) and the Project IAM Admin role (roles/resourcemanager.projectIamAdmin). Learn how to grant roles.

    2. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
    3. Select your project.

    4. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

    5. Click Create and continue.

    6. Grant the Project > Owner role to the service account.

      To grant the role, find the Select a role list, then select Project > Owner.

    7. Click Continue.

    8. Click Done to finish creating the service account.

  13. Instal Google Cloud CLI.

  14. Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

  15. Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut: 

    gcloud init
  16. Buat penawaran SaaS. Anda memerlukan penawaran SaaS untuk menyelesaikan panduan memulai ini. Untuk mengetahui informasi selengkapnya tentang cara membuat penawaran SaaS, lihat Membuat penawaran SaaS.

Memberikan izin ke akun layanan App Lifecycle Manager

Saat Anda mengaktifkan App Lifecycle Manager API, App Lifecycle Manager akan membuat akun layanan. Akun layanan ini disebut service-PROJECT-NUMBER@gcp-sa-saasservicemgmt.iam.gserviceaccount.com, dengan PROJECT-NUMBER adalah nomor project Anda.

Berikan izin yang diperlukan ke akun layanan ini dengan menjalankan perintah berikut:

gcloud projects add-iam-policy-binding `PROJECT_ID` \
    --member="serviceAccount:service-<var>`PROJECT_NUMBER`</var>@gcp-sa-saasservicemgmt.iam.gserviceaccount.com" \
    --role="roles/saasservicemgmt.serviceAgent"

Ganti:

  • PROJECT_ID: ID project Anda yang berupa string.
  • PROJECT_NUMBER: Nomor project Anda.

Menemukan dokumentasi referensi

Akun layanan ini bertindak atas nama Anda untuk berbagai tugas seperti unit penyediaan.

Membuat repositori di Artifact Registry

Untuk menggunakan App Lifecycle Manager, Anda memerlukan repositori di Artifact Registry. Untuk membuat repositori ini, jalankan perintah berikut di terminal Anda:

gcloud artifacts repositories create flags-quickstart \
    --repository-format=docker \
    --location=us-central1

Repositori ini akan berisi cetak biru (file Terraform yang dikemas) yang menjelaskan cara menyediakan unit Anda.

Membuat cetak biru aplikasi pemberian tombol fitur

Buat skrip Python yang membaca tombol fitur dan gunakan untuk mem-build dan mengirim image Docker:

  1. Buat direktori bernama alm_docker untuk konteks build Docker Anda.

  2. Di direktori alm_docker, buat file flags.py dengan cuplikan ini:

    import google.auth.transport.grpc
import google.auth.transport.requests
import grpc
import logging
import time
import os
import sys
from flask import Flask, jsonify

from openfeature import api
from openfeature.provider import ProviderEvent, ProviderStatus
from openfeature.contrib.provider.flagd import FlagdProvider
from openfeature.contrib.provider.flagd.config import ResolverType

# --- Flask App Setup ---
app = Flask(__name__)

# --- Logging Setup ---
logging.basicConfig(stream=sys.stdout) # Log to stdout for Cloud Run
log = logging.getLogger(__name__)
log.setLevel(logging.INFO) # Use INFO or DEBUG as needed

# --- OpenFeature/Flagd Setup ---
FLAG_KEY = "quickstart-flag"
DEFAULT_FLAG_VALUE = False

# Check for necessary environment variable
provider_id = os.environ.get("FLAGD_SOURCE_PROVIDER_ID")
if not provider_id:
  log.critical("FATAL: FLAGD_SOURCE_PROVIDER_ID environment variable not set.")
  sys.exit("FLAGD_SOURCE_PROVIDER_ID not set") # Exit if critical config is missing

log.info(f"Initializing OpenFeature provider for ID: {provider_id}")

def add_x_goog_request_params_header(config_name):
  return lambda context, callback: callback([("x-goog-request-params", f'name={config_name}')], None)

try:
  # Configure gRPC credentials for Google Cloud service
  configservice_credentials = grpc.composite_channel_credentials(
      grpc.ssl_channel_credentials(),
      grpc.metadata_call_credentials(
          google.auth.transport.grpc.AuthMetadataPlugin(
              google.auth.default()[0], # Get just the credentials from the tuple
              google.auth.transport.requests.Request()
          )
      ),
      grpc.metadata_call_credentials(
          add_x_goog_request_params_header(provider_id)
      )
  )

  # Set up the Flagd provider to connect to SaaS Config service
  # Using IN_PROCESS resolver type as recommended for direct gRPC connection
  provider = FlagdProvider(
      resolver_type=ResolverType.IN_PROCESS,
      host="saasconfig.googleapis.com",
      port=443,
      sync_metadata_disabled=True, # Important when using IN_PROCESS with direct service
      provider_id=provider_id,
      channel_credentials=configservice_credentials
  )
  api.set_provider(provider)
  client = api.get_client()

  initial_flag_value = client.get_boolean_value(FLAG_KEY, DEFAULT_FLAG_VALUE)
  log.info(f"***** STARTUP FLAG CHECK ***** Flag '{FLAG_KEY}' evaluated to: {initial_flag_value}")

except Exception as e:
  log.critical(f"FATAL: Failed to initialize OpenFeature provider: {e}", exc_info=True)
  # Depending on the desired behavior, you might exit or let Flask start
  # but log the critical failure. Exiting might be safer in production.
  sys.exit(f"Provider initialization failed: {e}")

# --- Flask Routes ---
@app.route('/')
def home():
  """Endpoint to check the feature flag's value."""
  log.info(f"Request received for flag: {FLAG_KEY}")
  try:
      # Get the flag value. Use the client initialized earlier.
      # The default value (DEFAULT_FLAG_VALUE) is returned if the flag isn't found
      # or if the provider isn't ready/errors occur during evaluation.
      flag_value = client.get_boolean_value(FLAG_KEY, DEFAULT_FLAG_VALUE)
      log.info(f"Evaluated flag '{FLAG_KEY}': {flag_value}")
      return jsonify({
          "flag_key": FLAG_KEY,
          "value": flag_value,
      })
  except Exception as e:
      log.error(f"Error evaluating flag '{FLAG_KEY}': {e}", exc_info=True)
      # Return an error response but keep the server running
      return jsonify({
          "error": f"Failed to evaluate flag {FLAG_KEY}",
          "details": str(e),
      }), 500

if __name__ == '__main__':
  port = int(os.environ.get('PORT', 8080))
  log.info(f"Starting Flask server on port {port}")
  app.run(host='0.0.0.0', port=port)

    Skrip Python ini menunjukkan cara mengakses tombol fitur dalam aplikasi Anda yang berjalan sebagai image Docker di unit App Lifecycle Manager. Skrip ini menggunakan prinsip OpenFeature standar untuk berintegrasi dengan layanan konfigurasi tombol fitur App Lifecycle Manager (saasconfig.googleapis.com).

  3. Buat file teks bernama requirements.txt di direktori alm_docker yang berisi cuplikan ini:

    google-auth
grpcio>=1.49.1,<2.0.0dev
openfeature-sdk==0.8.0
openfeature-provider-flagd==0.2.2
requests 
typing_extensions
Flask>=2.0

  4. Tambahkan Dockerfile di direktori alm_docker dengan:

    FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt
COPY flags.py .
CMD ["python", "flags.py"]

  5. Jalankan perintah ini di lingkungan lokal Anda untuk mem-build dan mengirim image Docker:

    export DOCKER_REGISTRY="us-central1-docker.pkg.dev/PROJECT_ID/flags-quickstart"
export FULL_IMAGE_PATH="${DOCKER_REGISTRY}/flags-quickstart:latest"
docker build -t "${FULL_IMAGE_PATH}" .
docker push "${FULL_IMAGE_PATH}"

    Ganti:

    • PROJECT_ID: ID project Anda yang berupa string.

  6. Di lingkungan Docker Anda, buat direktori alm_terraform.

  7. Di alm_terraform, buat file berikut:

    main.tf

    locals {
  config_path = "projects/${var.system_unit_project}/locations/${var.system_unit_location}/featureFlagsConfigs/${var.system_unit_name}"
  docker_image_path = "${var.system_unit_location}-docker.pkg.dev/${var.system_unit_project}/${var.docker_repo_name}/${var.docker_tag}"
}

provider "google" {
  project = var.system_unit_project
  region  = var.system_unit_location
}

resource "google_cloud_run_service" "flags_quickstart_service" {
  name     = var.cloud_run_service_name
  location = var.system_unit_location
  project  = var.system_unit_project

  template {
    spec {
      containers {
        image = local.docker_image_path 

        env {
          name  = "FLAGD_SOURCE_PROVIDER_ID"
          value = local.config_path
        }
      }
      service_account_name = var.actuation_sa
    }
  }
}

    variables.tf

    variable "actuation_sa" {
  description = "Actuation SA"
  type        = string
}

variable "system_unit_project" {
  description = "Project id - variable set by App Lifecycle Manager"
  type        = string
}

variable "system_unit_location" {
  description = "Location - variable set by App Lifecycle Manager"
  type        = string
}

variable "system_unit_name" {
  description = "Unit name- variable set by App Lifecycle Manager"
  type = string
}

variable "docker_repo_name" {
  description = "The name of the Artifact Registry repository where the Docker image is stored."
  type        = string
  default     = "flags-quickstart"
}

variable "docker_tag" {
  description = "The tag of the Docker image to deploy."
  type        = string
  default     = "flags-quickstart:latest"
}

variable "cloud_run_service_name" {
  description = "Name for the Cloud Run service to be created."
  type        = string
  default     = "saas-flags-quickstart-svc"
}

  8. Di direktori alm_terraform, jalankan perintah ini untuk mengemas file cetak biru Terraform:

    zip terraform-files.zip main.tf variables.tf

Menggunakan cetak biru aplikasi untuk membuat unit

Setelah membuat cetak biru aplikasi yang menggunakan tombol fitur, Anda harus membuat jenis unit App Lifecycle Manager (flags-unit-kind), lalu membuat unit jenis ini (flags-quickstart-unit).

Untuk mengetahui informasi selengkapnya tentang unit dan jenis unit, lihat Unit model dan paket deployment.

Untuk menggunakan cetak biru aplikasi guna membuat unit, ikuti langkah-langkah gcloud CLI berikut:

  1. Untuk mengemas konfigurasi Terraform Anda sebagai image OCI (cetak biru), buat file bernama Dockerfile di direktori Terraform Anda:

    # syntax=docker/dockerfile:1-labs
FROM scratch
COPY --exclude=Dockerfile --exclude=.git --exclude=.gitignore . /

  2. Build dan kirim Dockerfile ke repositori Artifact Registry Anda:

    IMAGE_NAME="us-central1-docker.pkg.dev/PROJECT_ID/flags-quickstart/flags-quickstart-blueprint:latest"
ENGINE_TYPE=inframanager
ENGINE_VERSION=1.5.7

docker buildx build -t $IMAGE_NAME \
  --push \
  --annotation "com.easysaas.engine.type=$ENGINE_TYPE" \
  --annotation "com.easysaas.engine.version=$ENGINE_VERSION" \
  --provenance=false .

    Ganti:

    • PROJECT_ID: ID project Anda yang berupa string.

  3. Buat resource flags-unit-kind dan flags-release:

    # Create unit kind
gcloud beta app-lifecycle-manager unit-kinds create flags-unit-kind \
  --project=PROJECT_ID \
  --location=global \
  --saas=flags-quickstart-saas-offering

# Create release referencing the Blueprint image
gcloud beta app-lifecycle-manager releases create flags-release \
  --project=PROJECT_ID \
  --location=global \
  --unit-kind=flags-unit-kind \
  --blueprint-package=$IMAGE_NAME

    Ganti:

    • PROJECT_ID: ID project Anda yang berupa string.

  4. Buat unit flags-quickstart-unit:

    gcloud beta app-lifecycle-manager units create flags-quickstart-unit \
  --project=PROJECT_ID \
  --location=us-central1 \
  --unit-kind=flags-unit-kind \
  --management-mode=user

    Ganti:

    • PROJECT_ID: ID project Anda yang berupa string.

Membuat dan menyediakan tombol fitur

Sebelum tombol fitur App Lifecycle Manager dapat digunakan oleh unit yang disediakan, Anda harus membuat resource tombol fitur dan memulai peluncuran untuk menyebarkan konfigurasi ke unit.

Jalankan perintah untuk membuat dan menyediakan tombol fitur quickstart-flag:

  1. Di lingkungan Anda, tentukan variabel berikut:

    export FLAG_ID="quickstart-flag"
export FLAG_KEY="quickstart-flag"
export SAAS_OFFERING_ID="flags-quickstart-saas-offering"
export UNIT_KIND_ID="flags-unit-kind"
export UNIT_ID="flags-quickstart-unit"
export ROLLOUT_KIND_ID="flags-quickstart-rollout-kind"
export ROLLOUT_ID="flags-quickstart-rollout"

  2. Buat resource tombol fitur:

    gcloud beta app-lifecycle-manager flags create ${FLAG_ID} \
  --project=${PROJECT_ID} \
  --key=${FLAG_KEY} \
  --flag-value-type=BOOL \
  --location=global \
  --unit-kind=${UNIT_KIND_ID}

  3. Buat revisi:

    export FLAG_REVISION_ID="${FLAG_ID}-rev1"
gcloud beta app-lifecycle-manager flags revisions create ${FLAG_REVISION_ID} \
  --project=${PROJECT_ID} \
  --flag=${FLAG_ID} \
  --location=global

  4. Buat rilis:

    export FLAG_RELEASE_ID="${FLAG_ID}-rel1"
gcloud beta app-lifecycle-manager flags releases create ${FLAG_RELEASE_ID} \
  --project=${PROJECT_ID} \
  --flag-revisions=${FLAG_REVISION_ID} \
  --unit-kind=${UNIT_KIND_ID} \
  --location=global

  5. Buat jenis peluncuran:

    gcloud beta app-lifecycle-manager rollout-kinds create ${ROLLOUT_KIND_ID} \
  --project=${PROJECT_ID} \
  --unit-kind=${UNIT_KIND_ID} \
  --rollout-orchestration-strategy=Google.Cloud.Simple.AllAtOnce \
  --location=global

  6. Buat peluncuran:

    gcloud beta app-lifecycle-manager rollouts create ${ROLLOUT_ID} \
  --project=${PROJECT_ID} \
  --flag-release=${FLAG_RELEASE_ID} \
  --rollout-kind=${ROLLOUT_KIND_ID} \
  --location=global

Anda dapat memantau status peluncuran dengan:

gcloud beta app-lifecycle-manager rollouts describe ${ROLLOUT_ID} --project=${PROJECT_ID} --location=global

Melihat nilai tombol di layanan yang berjalan

Setelah unit App Lifecycle Manager berhasil menyediakan layanan Cloud Run, Anda dapat memverifikasi bahwa aplikasi Anda berjalan dan mengevaluasi tombol fitur dengan benar:

  1. Di Google Cloud konsol, buka Cloud Run:

    Buka Cloud Run

  2. Temukan layanan bernama saas-flags-quickstart-svc di region us-central1. Tanda centang di samping saas-flags-quickstart-svc menunjukkan bahwa layanan tersebut berjalan dengan sukses.

  3. Klik saas-flags-quickstart-svc untuk melihat detailnya.

    Buka saas-flags-quickstart-svc.

  4. Pilih tab Logs.

    1. Di entri log, cari pesan yang mirip dengan yang berikut ini:

      INFO:__main__:***** STARTUP FLAG CHECK ***** Flag 'quickstart-flag' evaluated to: false

      Hal ini mengonfirmasi bahwa aplikasi dimulai, terhubung ke layanan Konfigurasi SaaS, dan mengevaluasi quickstart-flag.

  5. Untuk mengakses endpoint publik, klik tab Networking.

    1. Temukan URL publik yang tercantum di bagian Endpoints.
    2. Klik URL untuk membukanya di browser Anda, atau gunakan alat seperti curl untuk mengaksesnya dari terminal Anda (misalnya, curl YOUR_SERVICE_URL).

    3. Setiap kali Anda mengakses URL, layanan akan mengevaluasi tombol fitur dan menampilkan nilai saat ini dalam format JSON. Contoh:

      {
  "flag_key": "quickstart-flag",
  "value": false
}

Anda telah berhasil men-deploy layanan yang membaca tombol fitur terkelola App Lifecycle Manager. Google Cloud Anda dapat bereksperimen dengan mengubah nilai tombol dan membuat peluncuran baru untuk melihat aplikasi Anda mengambil perubahan tersebut.

Pembersihan

Agar akunAnda tidak dikenai biaya untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut. Google Cloud

Opsional: Menghapus project

Jika Anda men-deploy solusi di project baru Google Cloud , dan jika Anda tidak lagi memerlukan project tersebut, hapus project tersebut dengan menyelesaikan langkah-langkah berikut:

  1. Di Google Cloud konsol, buka halaman Manage resources.

    Buka Kelola resource

  2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Hapus.
  3. Pada layar perintah, ketik project ID, lalu klik Matikan.

Langkah berikutnya