Créer une application à partir de ressources existantes

Ce guide de démarrage rapide vous explique comment organiser desressources existantes dans une application App Hub en les enregistrant en tant que services.Ce guide de démarrage rapide vous explique comment organiser des Google Cloud ressources existantes dans une application App Hub en les enregistrant en tant que services. Tout d'abord, vous déployez des exemples de composants, que vous utilisez ensuite pour définir une application Web globale dans App Hub.

Ce guide de démarrage rapide s'adresse aux utilisateurs qui souhaitent utiliser leur infrastructure existante pour gagner en visibilité et en contrôle opérationnel en regroupant les Google Cloud ressources dans des applications logiques.

Avant de commencer

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

  1. Choisissez votre modèle de configuration d'application. Ce guide de démarrage rapide suppose que vous avez défini une limite de gestion des applications et crée une application à l'aide du projet de gestion. Pour en savoir plus sur cette configuration de ressources, consultez le modèle de ressources App Hub.

  2. Notez l'ID du projet de gestion à utiliser tout au long de ce document. Pour en savoir plus, consultez Trouver le nom, le numéro et l'ID du projet.

  3. Vérifiez que les API suivantes sont activées dans le projet de gestion. Lorsque vous configurez un projet de gestion, 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 des exemples de composants pour l'application

Vous devez d'abord déployer un ensemble de ressources d'exemple que vous utiliserez ultérieurement pour définir une application globale dans App Hub en les enregistrant en tant que composants d'application : Google Cloud

  • Un service Cloud Run qui fait office de service de backend de l'application.
  • Un équilibreur de charge d'application externe global qui fait office de service de frontend de l'application en dirigeant le trafic vers le service Cloud Run en tant que règle de transfert.

Procédez comme suit pour déployer ces ressources :

gcloud

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

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

    Remplacez les éléments suivants :

  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 distribution du trafic vers le NEG :

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

    3. Ajoutez le NEG sans serveur 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 requêtes 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 :

    Ce bloc définit le Google Cloud fournisseur et configure un service Cloud Run public à l'aide d'un exemple hello-world d'image de conteneur. 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 fait office de backend pour 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 entrantes des utilisateurs et les redirige 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 App Hub en les enregistrant en tant que services de l'application :

Console

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

    Accéder à la page Applications

  2. Cliquez sur Créer une application.

  3. Dans l'onglet Détails de l'application, sélectionnez Global comme emplacement de l'application.

  4. Saisissez my-global-app dans le champ Nom de l'application.

  5. Vous pouvez également ajouter un nom à afficher et une description pour l'application.

  6. Cliquez sur Continuer.

  7. Dans l'onglet Ressources de l'application, parcourez les ressources d'infrastructure et cochez les cases de la règle de transfert et du service Cloud Run.

  8. Cliquez sur Continuer.

  9. Dans l'onglet Attributs et propriétaires , vous pouvez ajouter des attributs pour l' application, tels que la criticité, l'environnement et les propriétaires de l'application.

    Vous pouvez choisir d'utiliser les mêmes attributs et propriétaires pour les ressources que vous enregistrez dans l'application ou les définir ultérieurement.

  10. Cliquez sur Créer.

Une fois l'application créée, la page Applications affiche ses détails, y compris les ressources que vous avez enregistrées en tant que services.

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 google_apphub_application ressource pour créer un regroupement logique des composants de l'application.

    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 recherchent les noms de ressources de votre infrastructure existante en fonction de leurs URI.google_apphub_discovered_service Cette étape permet à App Hub d'identifier les ressources spécifiques que vous souhaitez enregistrer en tant que services.

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

    # 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 google_apphub_service ressources enregistrent officiellement les ressources découvertes dans votre application en tant que services. Cette étape associe votre infrastructure à 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 des produits intégrés Google Cloud pour surveiller son état et ses performances :

Libérer de l'espace

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

  1. Annulez l'enregistrement des services.
  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 annuler le provisionnement de toutes les ressources que vous avez créées.
  4. Facultatif : Si vous avez créé un projet pour ce guide de démarrage rapide, supprimez-le.

Étape suivante