Anwendungsprobleme mit Gemini Cloud Assist finden und beheben

1. Einführung

Gemini Cloud Assist ist ein Agent mit vollem Funktionsumfang, der Ihre Google Cloud-Arbeitslasten unterstützt. Der Agent unterstützt Sie beim Entwerfen neuer Anwendungen oder beim Aktualisieren vorhandener Anwendungen, beim Bereitstellen und Ausführen von Arbeitslasten in Google Cloud, bei der Fehlerbehebung bei Arbeitslasten und bei der Optimierung von Arbeitslasten in Bezug auf Kosten und Leistung.

Gemini Cloud Assist verbessert Ihre Fähigkeit, auf unerwartete Fehler und Ausfallzeiten zu reagieren.

Lerninhalte

1. Bereitstellung: So stellen Sie ein einfaches Backend und eine einfache Datenbank in Google Cloud bereit.
2. Debugging: Gemini Cloud Assist automatisiert die Untersuchung und Ursachenanalyse von Cloud- und Code-Problemen.
3. Abhilfe: Wie Gemini Cloud Assist anhand der Ursache Korrekturen identifiziert.

Gemini Cloud Assist Investigations ist in der privaten Vorschau verfügbar. Prüfen Sie, ob Sie für diese Funktion auf der Zulassungsliste stehen, bevor Sie mit diesem Lab beginnen.

2. Projekt einrichten

Google-Konto

Wenn Sie noch kein privates Google-Konto haben, müssen Sie ein Google-Konto erstellen.

Verwenden Sie stattdessen ein privates Konto.

Bei Arbeitskonten und Konten von Bildungseinrichtungen kann es Einschränkungen geben, die verhindern, dass Sie die für dieses Lab erforderlichen APIs aktivieren.

In der Google Cloud Console anmelden

Melden Sie sich mit einem privaten Google-Konto in der Google Cloud Console an.

Abrechnung aktivieren

Privates Rechnungskonto einrichten

Wenn Sie die Abrechnung mit Google Cloud-Guthaben eingerichtet haben, können Sie diesen Schritt überspringen.

Aktivieren Sie die Abrechnung in der Cloud Console, um ein privates Rechnungskonto einzurichten.

Hinweise:

• Für dieses Lab sollten weniger als 1 $für Cloud-Ressourcen anfallen.
• Sie können die Schritte am Ende dieses Labs ausführen, um Ressourcen zu löschen und so weitere Kosten zu vermeiden.
• Neue Nutzer haben Anspruch auf die kostenlose Testversion mit einem Guthaben von 300$.

Projekt erstellen (optional)

Wenn Sie kein aktuelles Projekt haben, das Sie für dieses Lab verwenden möchten, erstellen Sie hier ein neues Projekt.

3. Cloud Shell-Editor öffnen

1. Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
2. Wenn Sie heute an irgendeinem Punkt zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren.
3. Wenn das Terminal nicht unten auf dem Bildschirm angezeigt wird, öffnen Sie es:
   • Klicken Sie auf Ansehen.
   • Klicken Sie auf Terminal.
4. Legen Sie im Terminal Ihr Projekt mit diesem Befehl fest:

   gcloud config set project [PROJECT_ID]
   

   • Beispiel:

     gcloud config set project lab-project-id-example
     

   • Wenn Sie sich nicht mehr an Ihre Projekt-ID erinnern, können Sie alle Ihre Projekt-IDs mit folgendem Befehl auflisten:

     gcloud projects list
     

     
5. Es sollte folgende Meldung angezeigt werden:

   Updated property [core/project].
   

   Wenn Sie WARNING sehen und gefragt werden, ob Sie Do you want to continue (Y/n)?, haben Sie die Projekt-ID wahrscheinlich falsch eingegeben. Drücken Sie n, dann Enter und versuchen Sie, den Befehl gcloud config set project noch einmal auszuführen.

4. APIs aktivieren

Aktivieren Sie die folgenden APIs für die Anwendungs-Komponenten, die bereitgestellt werden sollen, und für die Verwendung von Google Cloud Assist:

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

Aktivieren Sie die APIs im Terminal:

```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. Projekt vorbereiten

Sie erstellen die grundlegende Anwendung und Bereitstellung, um Cloud Assist zu testen.

Verzeichnis erstellen

1. Öffnen Sie den Cloud Shell-Editor oder Ihre bevorzugte Entwicklungsumgebung.
2. So erstellen Sie einen neuen Ordner:

   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. Führen Sie im Terminal den folgenden Befehl aus, um einen Cloud Shell-Editor-Arbeitsbereich zu öffnen:

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

Wenn das Terminal verschwindet, können Sie es wieder öffnen, indem Sie im oberen Menü auf Ansicht und dann auf Terminal klicken.

Dateien erstellen

Als Nächstes erstellen Sie die erforderlichen Startdateien für die Anwendung.

1. Erstellen Sie das Dockerfile, indem Sie Folgendes im Terminal ausführen. In dieser Datei wird der Anwendungscontainer erstellt.

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. Erstellen Sie die Datei main.py, indem Sie Folgendes im Terminal ausführen. Diese Datei enthält die in Python geschriebene Anwendung.

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. Erstellen Sie die Datei requirements.txt, indem Sie Folgendes im Terminal ausführen. Diese Datei enthält die Anforderungen für Python-Pakete.

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. Erstellen Sie die Datei main.tf, indem Sie Folgendes im Terminal ausführen. In dieser Datei werden die Google Cloud-Ressourcen behandelt, die erstellt werden sollen.

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. Erstellen Sie die Datei variables.tf, indem Sie Folgendes im Terminal ausführen. In dieser Datei werden Terraform-Variablen für die Google Cloud-Ressourcen verarbeitet.

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. Erstellen Sie die Datei setup_via_tf.sh, indem Sie Folgendes im Terminal ausführen. Diese Datei enthält die Anforderungen für Python-Pakete.

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. Führen Sie den folgenden Befehl aus, um das Shell-Script ausführbar zu machen:

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

8. Erstellen Sie eine .env-Datei mit Ihrer Google Cloud-Projekt-ID für die Bereitstellung. Aktualisieren Sie das Feld YOUR_PROJECT_ID:

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

6. Anwendung bereitstellen

Der Anwendungscode und die Google Cloud-Ressourcen sind bereit für die Bereitstellung. Das kann bis zu 15 Minuten dauern.

Führen Sie den folgenden Befehl über das Terminal aus:

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

Während die Komponenten bereitgestellt werden, können Sie sich die Dateien im Cloud Shell-Editor ansehen, um mehr zu erfahren.

7. Fehler erstellen und beheben

Als Nächstes lösen wir einen Fehler in der Anwendung aus. Öffnen Sie im linken Bereich Cloud Run. Klicken Sie dann auf den Dienst auth-issue-demo.

1. Oben auf der Seite Dienstdetails befindet sich eine URL. Kopieren Sie die URL und öffnen Sie einen neuen Browsertab. Fügen Sie die URL ein und fügen Sie /connect hinzu. Ihre URL sieht etwa so aus:

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

2. Rufen Sie die URL auf. Es kann einige Sekunden dauern, bis die Cloud Run-Instanz gestartet wird. Sie würden eine Fehlermeldung erhalten.
3. Kehren Sie zur Seite Cloud Run-Servicedetails zurück. Klicken Sie auf Beobachtbarkeit und dann auf Logs. Sie sehen die Logs für den Container, einschließlich eines Fehlers. Wenn das Fehlerlog noch nicht verfügbar ist, warten Sie einige Sekunden und aktualisieren Sie die Seite über das Symbol oben rechts.
4. Klicken Sie auf das Fehlerlog, um mehr zu erfahren. Klicken Sie in der Zeile des Hauptlogs auf das Symbol zum Untersuchen. Klicken Sie dann auf Log untersuchen.

Der Cloud Assist-Chatbereich wird geöffnet. Die Untersuchung dauert 2 bis 3 Minuten.

Nach Abschluss der Untersuchung können Sie die Ergebnisse und Empfehlungen lesen. Es wird empfohlen, dem Dienstkonto die richtige Berechtigung für Cloud Run hinzuzufügen, damit es auf die AlloyDB-Instanz zugreifen kann.

8. Fehler beheben

Beheben Sie den Fehler bei der Dienstkontoberechtigung.

1. Rufen Sie Cloud IAM auf.
2. Klicken Sie auf den Button Zugriff gewähren. Geben Sie im Hauptkontobereich zuerst auth-demo ein und warten Sie, bis das Dienstkonto angezeigt wird.
3. Fügen Sie dem Dienstkonto als Nächstes die Rolle AlloyDB Client hinzu und klicken Sie dann auf Speichern.

Es kann bis zu einer Minute dauern, bis die Änderungen übernommen werden.

Warten Sie dann und aktualisieren Sie die Anwendung. Sie sehen jetzt eine Erfolgsmeldung von der AlloyDB-Datenbank.

9. Glückwunsch

Glückwunsch! Sie haben diese Einführung in Cloud Investigations und den Prozess zum Debuggen der Berechtigungen einer Anwendung in Google Cloud erfolgreich abgeschlossen.

Nächste Schritte

• Weitere Anleitungen und Beispiele für die Verwendung von Gemini Cloud Assist in verschiedenen Szenarien finden Sie hier:
  • Probleme mit Gemini in Google Cloud beheben
  • Neue Anwendung mit Gemini in Google Cloud entwerfen und bereitstellen
• Weitere Informationen zu den Funktionen und Leistungsmerkmalen von Gemini Cloud Assist finden Sie in der Dokumentation zu Gemini Cloud Assist.