Trouver et résoudre les problèmes d'application avec Gemini Cloud Assist

1. Introduction

Gemini Cloud Assist est un agent complet qui prend en charge vos charges de travail Google Cloud. L'agent est votre partenaire pour concevoir de nouvelles applications ou mettre à jour celles existantes, déployer et exécuter des charges de travail dans Google Cloud, résoudre les problèmes liés aux charges de travail et les optimiser en termes de coûts et de performances.

Gemini Cloud Assist vous aide à mieux répondre aux erreurs inattendues et aux temps d'arrêt.

Points abordés

1. Déploiement : découvrez comment déployer un backend et une base de données de base sur Google Cloud.
2. Débogage : découvrez comment Gemini Cloud Assist automatise l'investigation et l'analyse des causes fondamentales des problèmes liés au cloud et au code.
3. Remédiation : comment Gemini Cloud Assist aide à identifier les correctifs en fonction de la cause première.

Gemini Cloud Assist Investigations est en version preview privée. Vérifiez que vous êtes autorisé à utiliser cette fonctionnalité avant de commencer cet atelier.

2. Configuration du projet

Compte Google

Si vous ne possédez pas encore de compte Google personnel, vous devez en créer un.

Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Il est possible que les comptes professionnels et scolaires soient soumis à des restrictions qui vous empêchent d'activer les API nécessaires pour cet atelier.

Se connecter à la console Google Cloud

Connectez-vous à la console Google Cloud à l'aide d'un compte Google personnel.

Activer la facturation

Configurer un compte de facturation personnel

Si vous avez configuré la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.

Pour configurer un compte de facturation personnel, cliquez ici pour activer la facturation dans la console Cloud.

Remarques :

• L'exécution de cet atelier devrait coûter moins de 1 USD en ressources Cloud.
• Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources et éviter ainsi des frais supplémentaires.
• Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour un crédit de 300 $.

Créer un projet (facultatif)

Si vous n'avez pas de projet que vous souhaitez utiliser pour cet atelier, créez-en un.

3. Ouvrir l'éditeur Cloud Shell

1. Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
2. Si vous êtes invité à autoriser l'accès à un moment donné, cliquez sur Autoriser pour continuer.
3. Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
   • Cliquez sur Afficher.
   • Cliquez sur Terminal.
4. Dans le terminal, définissez votre projet à l'aide de la commande suivante :

   gcloud config set project [PROJECT_ID]
   

   • Exemple :

     gcloud config set project lab-project-id-example
     

   • Si vous ne vous souvenez pas de votre ID de projet, vous pouvez l'obtenir en exécutant la commande suivante :

     gcloud projects list
     

     
5. Le message suivant doit s'afficher :

   Updated property [core/project].
   

   Si le message WARNING s'affiche et que vous êtes invité à Do you want to continue (Y/n)?, cela signifie probablement que vous avez saisi l'ID du projet de manière incorrecte. Appuyez sur n, puis sur Enter, et réessayez d'exécuter la commande gcloud config set project.

4. Activer les API

Activez les API suivantes pour déployer les composants de l'application et utiliser Google Cloud Assist :

• Gemini Cloud Assist
• Cloud Run
• AlloyDB
• Cloud Build
• Artifact Registry

Dans le terminal, activez les API :

```bash
gcloud services enable \
  container.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  alloydb.googleapis.com \
  run.googleapis.com
```
<br>
When the command finishes, you should see an output like the following: 
<br>

```console
Operation "operations/acf.p2-176675280136-b03ab5e4-3483-4ebf-9655-43dc3b345c63" finished successfully.
```

5. Préparer le projet

Vous allez créer l'application et le déploiement de base pour tester Cloud Assist.

Créez le répertoire.

1. Ouvrez l'éditeur Cloud Shell ou l'environnement de développement de votre choix.
2. Créer un dossier :

   mkdir -p ~/gemini-cloud-assist-debug
   mkdir -p ~/gemini-cloud-assist-debug/auth_issue_demo
   mkdir -p ~/gemini-cloud-assist-debug/terraform
   cd ~/gemini-cloud-assist-debug
   

3. Dans le terminal, exécutez la commande suivante pour ouvrir un espace de travail de l'éditeur Cloud Shell :

cloudshell open-workspace ~/gemini-cloud-assist-debug

Si le terminal disparaît lorsque vous effectuez cette opération, vous pouvez le rouvrir en cliquant sur Afficher, puis sur Terminal dans le menu du haut.

Créer les fichiers

Vous allez maintenant créer les fichiers de démarrage nécessaires pour l'application.

1. Créez le fichier Dockerfile en exécutant la commande suivante dans le terminal. Ce fichier gère la création du conteneur d'application.

cat <<EOF > ~/gemini-cloud-assist-debug/auth_issue_demo/Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY main.py .

CMD ["gunicorn", "--bind", "0.0.0.0:8080", "main:app"]
EOF

2. Créez le fichier main.py en exécutant la commande suivante dans le terminal. Ce fichier contient l'application écrite en Python.

cat <<EOF > ~/gemini-cloud-assist-debug/auth_issue_demo/main.py
import os
import logging
from flask import Flask
from google.cloud.alloydb.connector import Connector
import sqlalchemy

app = Flask(__name__)

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration from Environment Variables
# The fully qualified instance URI: projects/<PROJECT>/locations/<REGION>/clusters/<CLUSTER>/instances/<INSTANCE>
ALLOYDB_URI = os.environ.get("ALLOYDB_URI") 
DB_USER = os.environ.get("DB_USER", "auth-debug")
DB_PASS = os.environ.get("DB_PASS", "debug-auth")
DB_NAME = os.environ.get("DB_NAME", "postgres")
USE_PUBLIC_IP = os.environ.get("USE_PUBLIC_IP", "false").lower() == "true"

# Initialize Connector lazily
_connector = None

def get_connector():
    global _connector
    if _connector is None:
        _connector = Connector()
    return _connector

def getconn():
    connector = get_connector()
    ip_type = "PUBLIC" if USE_PUBLIC_IP else "PRIVATE"
    
    conn = connector.connect(
        ALLOYDB_URI,
        "pg8000",
        user=DB_USER,
        password=DB_PASS,
        db=DB_NAME,
        ip_type=ip_type
    )
    return conn

@app.route("/")
def index():
    return "AlloyDB Auth Demo. /connect to test.", 200

@app.route("/connect")
def connect_db():
    if not ALLOYDB_URI:
        return "FAILURE: ALLOYDB_URI env var is not set.", 500

    try:
        logger.info(f"Attempting connection to {ALLOYDB_URI} with user {DB_USER}...")
        
        # Create connection pool
        pool = sqlalchemy.create_engine(
            "postgresql+pg8000://",
            creator=getconn,
        )
        
        with pool.connect() as db_conn:
            # Simple query to validate connection
            result = db_conn.execute(sqlalchemy.text("SELECT NOW()")).fetchone()
            timestamp = result[0]
            
        msg = f"SUCCESS: Connected to AlloyDB! DB Time: {timestamp}"
        logger.info(msg)
        return msg, 200

    except Exception as e:
        logger.exception("Connection failed")
        # Return the error to the caller to visualize the auth failure
        return f"FAILURE: Connection Error.\nDetails: {str(e)}", 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF

3. Créez le fichier requirements.txt en exécutant la commande suivante dans le terminal. Ce fichier gère les exigences du package Python.

cat <<EOF > ~/gemini-cloud-assist-debug/auth_issue_demo/requirements.txt
flask==3.1.3
gunicorn==25.3.0
google-cloud-alloydb-connector[pg8000]==1.12.1
sqlalchemy==2.0.49
EOF

4. Créez le fichier main.tf en exécutant la commande suivante dans le terminal. Ce fichier gère les ressources Google Cloud à créer.

cat <<EOF > ~/gemini-cloud-assist-debug/terraform/main.tf
provider "google" {
  project = var.project_id
  region  = var.region
}

# Enable APIs
locals {
  apis = [
    "alloydb.googleapis.com",
    "run.googleapis.com",
    "artifactregistry.googleapis.com",
    "compute.googleapis.com",
    "geminicloudassist.googleapis.com",
    "monitoring.googleapis.com",
    "cloudasset.googleapis.com",
    "cloudbuild.googleapis.com",
    "recommender.googleapis.com",
    "appoptimize.googleapis.com"
  ]
}

resource "random_password" "db_pass" {
  count            = var.db_password == null ? 1 : 0
  length           = 16
  special          = true
  override_special = "!#$%&*()-_=+[]{}<>:?"
}

locals {
  db_password = var.db_password != null ? var.db_password : random_password.db_pass[0].result
}

resource "google_project_service" "apis" {
  for_each           = toset(local.apis)
  service            = each.value
  disable_on_destroy = false
}

# Service Account
resource "google_service_account" "auth_demo_sa" {
  account_id   = var.service_account_name
  display_name = "Auth Demo SA"
}

# AlloyDB Cluster
resource "google_alloydb_cluster" "rma_cluster" {
  cluster_id = var.cluster_id
  location   = var.region

  # Initial password, managed via variable or generated randomly
  initial_user {
    password = local.db_password
  }

  # Use default network as in the manual setup
  network_config {
    network = "projects/${var.project_id}/global/networks/default"
  }

  depends_on = [google_project_service.apis["alloydb.googleapis.com"]]
}

# AlloyDB Instance
resource "google_alloydb_instance" "rma_instance_1" {
  cluster       = google_alloydb_cluster.rma_cluster.name
  instance_id   = var.instance_id
  instance_type = "PRIMARY"

  machine_config {
    cpu_count = 2
  }

  network_config {
    enable_public_ip = true
  }

  depends_on = [google_alloydb_cluster.rma_cluster]
}

# Cloud Run Service
resource "google_cloud_run_service" "auth_issue_demo" {
  name     = var.cloud_run_service_name
  location = var.region

  template {
    spec {
      containers {
        image = var.cloud_run_image
        env {
          name  = "ALLOYDB_URI"
          value = "projects/${var.project_id}/locations/${var.region}/clusters/${var.cluster_id}/instances/${var.instance_id}"
        }
        env {
          name  = "DB_USER"
          value = "postgres"
        }
        env {
          name  = "DB_PASS"
          value = local.db_password
        }
        env {
          name  = "USE_PUBLIC_IP"
          value = "true"
        }
      }
      service_account_name = google_service_account.auth_demo_sa.email
    }
  }

  traffic {
    percent         = 100
    latest_revision = true
  }

  depends_on = [google_project_service.apis["run.googleapis.com"], google_alloydb_instance.rma_instance_1]
}

# Allow unauthenticated access to Cloud Run service (matching --allow-unauthenticated)
resource "google_cloud_run_service_iam_member" "public_access" {
  location = google_cloud_run_service.auth_issue_demo.location
  project  = google_cloud_run_service.auth_issue_demo.project
  service  = google_cloud_run_service.auth_issue_demo.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}
EOF

5. Créez le fichier variables.tf en exécutant la commande suivante dans le terminal. Ce fichier gère les variables Terraform pour les ressources Google Cloud.

cat <<EOF > ~/gemini-cloud-assist-debug/terraform/variables.tf
variable "project_id" {
  description = "The ID of the Google Cloud project."
  type        = string
}

variable "region" {
  description = "The region to deploy resources in."
  type        = string
  default     = "us-central1"
}

variable "cluster_id" {
  description = "The ID of the AlloyDB cluster."
  type        = string
  default     = "rma-cluster"
}

variable "instance_id" {
  description = "The ID of the AlloyDB instance."
  type        = string
  default     = "rma-instance-1"
}

variable "service_account_name" {
  description = "The name of the service account."
  type        = string
  default     = "auth-demo-sa"
}

variable "cloud_run_service_name" {
  description = "The name of the Cloud Run service."
  type        = string
  default     = "auth-issue-demo"
}

variable "cloud_run_image" {
  description = "The container image for the Cloud Run service."
  type        = string
}

variable "db_password" {
  description = "The database password. If not provided, a random one will be generated."
  type        = string
  sensitive   = true
  default     = null
}
EOF

6. Créez le fichier setup_via_tf.sh en exécutant la commande suivante dans le terminal. Ce fichier gère les exigences du package Python.

cat <<EOF > ~/gemini-cloud-assist-debug/setup_via_tf.sh
#!/bin/bash
set -e

# Get script directory and change to project root
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd "$SCRIPT_DIR"

# Load configuration from .env
if [ -f .env ]; then
    set -a
    source .env
    set +a
else
    echo "ERROR: .env file not found. Please create one with PROJECT_ID."
    exit 1
fi

if [ -z "$PROJECT_ID" ]; then
    echo "ERROR: PROJECT_ID is not set in .env file."
    exit 1
fi

REGION="us-central1"
CLUSTER_ID="rma-cluster"
INSTANCE_ID="rma-instance-1"
SA_NAME="auth-demo-sa"
SERVICE_NAME="auth-issue-demo"

echo "--- Terraform Setup for Auth Demo ---"
echo "Using Project: $PROJECT_ID"

# Get current Cloud Run image
echo "Fetching current Cloud Run image..."
IMAGE=$(gcloud run services describe $SERVICE_NAME --region=$REGION --project=$PROJECT_ID --format="value(spec.template.spec.containers[0].image)" 2>/dev/null || true)

if [ -z "$IMAGE" ]; then
    echo "WARNING: Could not find existing Cloud Run service image."
    echo "Using a placeholder image (gcr.io/cloudrun/hello) for initial Terraform apply."
    IMAGE="gcr.io/cloudrun/hello"
fi

echo "Found Image: $IMAGE"

cd terraform

# Initialize Terraform
echo "Initializing Terraform..."
terraform init

echo "Formatting Terraform files..."
terraform fmt

echo "Validating Terraform configuration..."
terraform validate

echo "------------------------------------------------"
echo "Applying changes..."
echo "------------------------------------------------"

terraform apply -var="project_id=$PROJECT_ID" -var="cloud_run_image=$IMAGE" -auto-approve

echo "------------------------------------------------"
echo "Building and deploying updated Cloud Run service..."
echo "------------------------------------------------"

gcloud run deploy $SERVICE_NAME \
  --source ../auth_issue_demo \
  --region $REGION \
  --project $PROJECT_ID \
  --service-account $SA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
  --quiet
EOF

7. Exécutez la commande suivante pour rendre le script shell exécutable :

chmod +x ~/gemini-cloud-assist-debug/setup_via_tf.sh

8. Créez un fichier .env contenant l'ID de votre projet Google Cloud pour le déploiement. Mettez à jour le champ YOUR_PROJECT_ID :

cat <<EOF > ~/gemini-cloud-assist-debug/.env
PROJECT_ID=YOUR_PROJECT_ID
USE_PUBLIC_IP=true
EOF

6. Déployer l'application

Le code de l'application et les ressources Google Cloud sont prêts à être déployés. Cette opération peut prendre jusqu'à 15 minutes.

Exécutez la commande suivante à partir du terminal :

cd ~/gemini-cloud-assist-debug
./setup_via_tf.sh

Pendant le déploiement des composants, parcourez les fichiers dans l'éditeur Cloud Shell pour en savoir plus.

7. Créer et déboguer une erreur

Nous allons maintenant déclencher une erreur à partir de l'application. Ouvrez Cloud Run dans le volet de gauche. Cliquez ensuite sur le service auth-issue-demo.

1. Une URL s'affiche en haut de la page Détails du service. Copiez l'URL et ouvrez un nouvel onglet du navigateur. Collez l'URL et ajoutez-y /connect. Votre URL ressemblera à ceci :

https://auth-issue-demo-.us-central1.run.app/connect

2. Accédez à l'URL. Le démarrage de l'instance Cloud Run peut prendre quelques secondes. Vous obtiendrez un message d'erreur.
3. Revenez à la page Cloud Run "Informations sur le service". Cliquez sur Observabilité, puis sur Journaux. Les journaux du conteneur, y compris une erreur, s'affichent. Si le journal des erreurs n'est pas encore disponible, patientez quelques secondes, puis actualisez la page à l'aide de l'icône en haut à droite.
4. Cliquez sur le journal d'erreurs pour en savoir plus. Cliquez sur l'icône Enquêter sur la ligne du journal principal. Cliquez ensuite sur Examiner le journal.

Le volet de chat Cloud Assist s'ouvre. L'enquête prend deux à trois minutes.

Une fois l'enquête terminée, vous pouvez lire les résultats et les recommandations. Il est recommandé d'ajouter l'autorisation appropriée au compte de service pour que Cloud Run puisse accéder à l'instance AlloyDB.

8. Corriger l'erreur

Corrigez l'erreur d'autorisation du compte de service.

1. Accédez à Cloud IAM.
2. Cliquez sur le bouton Accorder l'accès. Dans le volet "Principal", commencez par saisir auth-demo, puis attendez que le compte de service s'affiche.
3. Ensuite, ajoutez le rôle AlloyDB Client au compte de service, puis cliquez sur Enregistrer.

La propagation prend jusqu'à une minute.

Une fois que vous avez attendu, revenez en arrière et actualisez l'application. Un message de réussite s'affiche alors dans la base de données AlloyDB.

9. Félicitations

Félicitations ! Vous avez terminé cette introduction à Cloud Investigations et au processus de débogage des autorisations d'une application sur Google Cloud.

Étape suivante

• Consultez d'autres guides et exemples montrant comment utiliser Gemini Cloud Assist dans différents scénarios :
  • Résoudre les problèmes liés à Gemini dans Google Cloud
  • Concevoir et déployer une application avec Gemini dans Google Cloud
• Consultez la documentation Gemini Cloud Assist pour en savoir plus sur ses fonctionnalités.