Créer une application à partir de ressources existantes

Ce guide de démarrage rapide vous explique comment organiser les services Google Cloud existants dans une application App Hub. Vous allez d'abord déployer un exemple de configuration, que vous utiliserez ensuite pour définir une application Web globale en enregistrant ses composants en tant qu'application dans App Hub.

Cette approche s'adresse aux utilisateurs qui souhaitent utiliser leur infrastructure existante pour gagner en visibilité et en contrôle opérationnel en regroupant les ressources dans des applications logiques.

Avant de commencer

Avant de commencer ce guide de démarrage rapide, procédez comme suit :

  1. Configurez App Hub avec un dossier compatible avec les applications.

  2. Notez l'ID du projet de gestion à utiliser tout au long de ce document.

  3. Vérifiez que les API suivantes sont activées dans le projet de gestion. Lorsque vous configurez un dossier compatible avec les applications, la plupart des API dont vous avez besoin pour ce guide de démarrage rapide sont activées automatiquement.

    • API Compute Engine (compute.googleapis.com)
    • API Infrastructure Manager (config.googleapis.com)

    Activer les API

Rôles requis

Pour obtenir les autorisations nécessaires pour activer les API requises et créer un exemple d'application à partir de ressources existantes, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet de gestion :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Déployer les ressources de l'application

Vous devez d'abord déployer un ensemble de ressources exemples que vous utiliserez ultérieurement pour définir une application globale dans App Hub :

  • Service Cloud Run qui sert de backend à l'application.
  • Équilibreur de charge d'application externe global qui redirige le trafic vers le service Cloud Run en tant que règle de transfert.

Pour déployer ces ressources, procédez comme suit :

gcloud

  1. Définissez les variables d'environnement requises :

    export PROJECT_ID="PROJECT_ID"
export REGION="REGION"

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet de gestion.
    • REGION : région de votre choix pour les ressources, par exemple us-central1.

  2. Déployez un exemple de service Cloud Run nommé hello-run :

    gcloud run deploy hello-run \
    --image=us-docker.pkg.dev/cloudrun/container/hello \
    --allow-unauthenticated \
    --region=${REGION} \
    --project=${PROJECT_ID}

  3. Créez l'équilibreur de charge d'application externe global. Ce processus comprend les étapes suivantes :

    1. Créez un groupe de points de terminaison du réseau (NEG) sans serveur appelé hello-run-neg :

      gcloud compute network-endpoint-groups create hello-run-neg \
    --region=${REGION} \
    --network-endpoint-type=serverless \
    --cloud-run-service=hello-run \
    --project=${PROJECT_ID}

      Le NEG fait office de backend pour l'équilibreur de charge et pointe vers votre service hello-run.

    2. Créez un service de backend pour gérer la façon dont le trafic est distribué au NEG :

      gcloud compute backend-services create hello-backend-service \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --project=${PROJECT_ID}

    3. Ajoutez le NEG sans serveur en tant que backend au service de backend :

      gcloud compute backend-services add-backend hello-backend-service \
    --global \
    --network-endpoint-group=hello-run-neg \
    --network-endpoint-group-region=${REGION} \
    --project=${PROJECT_ID}

    4. Créez un mappage d'URL pour acheminer les requêtes entrantes vers le service de backend :

      gcloud compute url-maps create hello-url-map \
    --default-service=hello-backend-service \
    --project=${PROJECT_ID}

    5. Créez un proxy HTTP pour recevoir les requêtes et les acheminer à l'aide du mappage d'URL :

      gcloud compute target-http-proxies create hello-http-proxy \
    --url-map=hello-url-map \
    --project=${PROJECT_ID}

    6. Créez une règle de transfert globale :

      gcloud compute forwarding-rules create hello-forwarding-rule \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --target-http-proxy=hello-http-proxy \
    --ports=80 \
    --project=${PROJECT_ID}

      Cette règle de transfert fournit une adresse IP publique et un port pour gérer les demandes entrantes des utilisateurs et les redirige vers le proxy.

Terraform

  1. Créez un fichier main.tf et ajoutez le code suivant :

    # Provider configuration
provider "google" {
  project = "PROJECT_ID"
}

# Cloud Run service
resource "google_cloud_run_v2_service" "default" {
  name     = "hello-run"
  location = "REGION"
  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }
}

# Allow unauthenticated access to the Cloud Run service
resource "google_cloud_run_v2_service_iam_member" "noauth" {
  project  = google_cloud_run_v2_service.default.project
  location = google_cloud_run_v2_service.default.location
  name     = google_cloud_run_v2_service.default.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet de gestion.
    • REGION : région de votre choix pour les ressources, par exemple us-central1.

    Ce bloc définit le fournisseur Google Cloud et configure un service Cloud Run public à l'aide d'un exemple d'image de conteneurhello-world. Il inclut également une liaison de stratégie IAM pour autoriser les appels non authentifiés, ce qui rend le service accessible au public.

  2. Ajoutez le code suivant à votre fichier main.tf pour créer l'équilibreur de charge d'application externe global :

    # Serverless NEG for the Cloud Run service
resource "google_compute_region_network_endpoint_group" "serverless_neg" {
  name                  = "hello-run-neg"
  network_endpoint_type = "SERVERLESS"
  region                = "REGION"
  cloud_run {
    service = google_cloud_run_v2_service.default.name
  }
}

# Global external backend service
resource "google_compute_backend_service" "default" {
  name                            = "hello-backend-service"
  protocol                        = "HTTP"
  load_balancing_scheme           = "EXTERNAL_MANAGED"
  backend {
    group = google_compute_region_network_endpoint_group.serverless_neg.id
  }
}

# URL map to route requests to the backend service
resource "google_compute_url_map" "default" {
  name            = "hello-url-map"
  default_service = google_compute_backend_service.default.id
}

# HTTP proxy to route requests to the URL map
resource "google_compute_target_http_proxy" "default" {
  name    = "hello-http-proxy"
  url_map = google_compute_url_map.default.id
}

# Global forwarding rule to handle incoming requests
resource "google_compute_global_forwarding_rule" "default" {
  name       = "hello-forwarding-rule"
  target     = google_compute_target_http_proxy.default.id
  port_range = "80"
}

    Ce bloc définit les composants suivants :

    • Un groupe de points de terminaison du réseau (NEG) sans serveur, qui sert de backend à l'équilibreur de charge et pointe vers le service Cloud Run.
    • Un service de backend qui dirige le trafic vers le NEG sans serveur.
    • Un mappage d'URL pour acheminer les requêtes entrantes vers le service de backend.
    • Un proxy HTTP pour recevoir les requêtes et les acheminer à l'aide du mappage d'URL.
    • Une règle de transfert globale, qui fournit une adresse IP publique et un port pour gérer les requêtes utilisateur entrantes et les rediriger vers le proxy.

  3. Initialisez et appliquez la configuration Terraform :

    terraform init
terraform apply

    Terraform déploie les ressources dans votre projet.

Définir l'application dans App Hub

Après avoir déployé les ressources en tant que règle de transfert et service Cloud Run, procédez comme suit pour les regrouper dans une application dans App Hub :

Console

  1. Accédez à la page Applications depuis App Hub :

    Accéder à la page Applications

  2. Cliquez sur Créer une application.

  3. Sélectionnez Global comme emplacement de l'application.

  4. Saisissez my-global-app pour le nom de l'application, puis cliquez sur Continuer.

  5. Vous pouvez éventuellement ajouter un nom à afficher, une criticité, un environnement et des propriétaires.

  6. Cliquez sur Créer.

  7. Dans l'onglet Services et charges de travail, cliquez sur Enregistrer un service/une charge de travail.

  8. Sélectionnez la règle de transfert, nommez-la frontend-service, puis cliquez sur Enregistrer.

  9. Sélectionnez le service Cloud Run, nommez-le backend-service, puis cliquez sur Enregistrer.

gcloud

  1. Créez l'application :

    gcloud apphub applications create my-global-app \
    --location=global \
    --display-name="My Global Application" \
    --project=${PROJECT_ID}

  2. Découvrez les ID de la règle de transfert et du service Cloud Run dans la région appropriée :

    gcloud apphub discovered-services list \
    --location=global \
    --project=${PROJECT_ID}

gcloud apphub discovered-services list \
    --location=${REGION} \
    --project=${PROJECT_ID}

    Notez l'ID de la règle de transfert et du service Cloud Run.

  3. Enregistrez la règle de transfert dans l'application globale :

    gcloud apphub applications services create frontend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/global/discoveredServices/FRONTEND_ID \
    --display-name="Frontend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Remplacez FRONTEND_ID par l'ID de la règle de transfert.

  4. Enregistrez le service Cloud Run dans l'application globale :

    gcloud apphub applications services create backend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/${REGION}/discoveredServices/BACKEND_ID \
    --display-name="Backend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Remplacez BACKEND_ID par l'ID du service Cloud Run.

Terraform

  1. Créez un fichier application.tf et ajoutez le code suivant :

    # Application
resource "google_apphub_application" "my_global_app" {
  project        = "PROJECT_ID"
  location       = "global"
  application_id = "my-global-app"
  display_name   = "My Global Web App"
  description    = "A sample global web application."
  scope {
    type = "GLOBAL"
  }
  attributes {
    criticality {
      type = "MEDIUM"
    }
    environment {
      type = "DEVELOPMENT"
    }
    business_owners {
      display_name = "Example Business Owner"
      email        = "business-owner@example.com"
    }
    developer_owners {
      display_name = "Example Developer"
      email        = "dev-owner@example.com"
    }
    operator_owners {
      display_name = "Example Operator"
      email        = "operator-owner@example.com"
    }
  }
}

    Ce bloc utilise la ressource google_apphub_application pour créer un regroupement logique pour vos services et charges de travail.

    Cet exemple crée une application globale et définit des attributs pour la gouvernance et la détectabilité, tels que la criticité, l'environnement et les propriétaires. Vous pouvez modifier ces valeurs pour votre exemple de configuration.

  2. Ajoutez le code suivant à application.tf pour découvrir vos ressources déployées :

    # Discover the forwarding rule
data "google_apphub_discovered_service" "frontend_service" {
  location = "global"
  service_uri = "//compute.googleapis.com/${google_compute_global_forwarding_rule.default.id}"
}

# Discover the Cloud Run service
data "google_apphub_discovered_service" "backend_service" {
  location    = "REGION"
  service_uri = "//run.googleapis.com/${google_cloud_run_v2_service.default.id}"
}

    Les sources de données google_apphub_discovered_service trouvent les noms de ressources de votre infrastructure existante en fonction de leurs URI. Cette étape permet à App Hub d'identifier les ressources spécifiques que vous souhaitez enregistrer.

  3. Ajoutez le code suivant à application.tf pour enregistrer les ressources détectées :

    # Register the forwarding rule as a service in the application
resource "google_apphub_service" "frontend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "frontend-service"
  display_name       = "Frontend Service (LB)"
  discovered_service = data.google_apphub_discovered_service.frontend_service.name
}

# Register the Cloud Run service as a service in the application
resource "google_apphub_service" "backend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "backend-service"
  display_name       = "Backend Service (Cloud Run)"
  discovered_service = data.google_apphub_discovered_service.backend_service.name
}

    Les ressources google_apphub_service enregistrent formellement les ressources découvertes dans votre application. Cette étape crée le lien entre votre infrastructure et l'application que vous avez définie dans App Hub.

  4. Initialisez et appliquez la configuration Terraform :

    terraform init
terraform apply

    Terraform enregistre les ressources dans votre application my-global-app dans App Hub.

Facultatif : Surveiller votre nouvelle application

Après avoir défini votre application dans App Hub, vous pouvez utiliser les servicesGoogle Cloud intégrés pour surveiller son état et ses performances :

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cette démonstration soient facturées sur votre compte Google Cloud , procédez comme suit :

  1. Annuler l'enregistrement des services et des charges de travail
  2. Supprimez l'application globale.
  3. Si vous avez utilisé Terraform pour déployer votre application, exécutez terraform destroy dans le répertoire contenant vos fichiers Terraform pour supprimer toutes les ressources que vous avez créées.
  4. Facultatif : Si vous avez créé un projet pour ce démarrage rapide, supprimez-le.

Étapes suivantes