Gemini Cloud Assist की मदद से, ऐप्लिकेशन से जुड़ी समस्याओं का पता लगाना और उन्हें ठीक करना

1. परिचय

Gemini Cloud Assist एक ऐसा एजेंट है जिसमें सभी सुविधाएँ उपलब्ध हैं. यह Google Cloud के वर्कलोड के साथ काम करता है. एजेंट, नए ऐप्लिकेशन डिज़ाइन करने या मौजूदा ऐप्लिकेशन अपडेट करने, Google Cloud में वर्कलोड डिप्लॉय और चलाने, वर्कलोड से जुड़ी समस्याओं को हल करने, और लागत और परफ़ॉर्मेंस के लिए उन्हें ऑप्टिमाइज़ करने में आपकी मदद करता है.

Gemini Cloud Assist की मदद से, अचानक होने वाली गड़बड़ियों और डाउनटाइम की समस्याओं को हल करने में मदद मिलती है.

आपको क्या सीखने को मिलेगा

1. डिप्लॉयमेंट: Google Cloud पर बुनियादी बैकएंड और डेटाबेस को डिप्लॉय करने का तरीका.
2. डीबग करना: Gemini Cloud Assist, क्लाउड और कोड से जुड़ी समस्याओं की जांच और उनके मूल कारण का विश्लेषण करने की प्रोसेस को कैसे अपने-आप पूरा करता है.
3. समस्या हल करना: Gemini Cloud Assist, समस्या की असल वजह के आधार पर समाधानों की पहचान करने में कैसे मदद करता है.

Gemini Cloud Assist Investigations की झलक पाने की सुविधा अभी कुछ ही लोगों के लिए उपलब्ध है. इस लैब को आज़माने से पहले, पुष्टि करें कि आपको इस सुविधा के लिए अनुमति मिली है.

2. प्रोजेक्ट सेटअप करना

Google खाता

अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

ऑफ़िस और स्कूल वाले खातों पर कुछ पाबंदियां हो सकती हैं. इनकी वजह से, इस लैब के लिए ज़रूरी एपीआई चालू नहीं किए जा सकते.

Google Cloud Console में साइन इन करना

किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.

बिलिंग चालू करें

निजी बिलिंग खाता सेट अप करना

अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ें.

निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.

ध्यान दें:

• इस लैब को पूरा करने में, Cloud संसाधनों पर 1 डॉलर से कम का खर्च आना चाहिए.
• ज़्यादा शुल्क से बचने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करके संसाधनों को मिटाया जा सकता है.
• नए उपयोगकर्ता, 300 डॉलर के मुफ़्त में आज़माने की सुविधा का फ़ायदा पा सकते हैं.

कोई प्रोजेक्ट बनाएं (ज़रूरी नहीं)

अगर आपके पास कोई ऐसा मौजूदा प्रोजेक्ट नहीं है जिसका इस्तेमाल आपको इस लैब के लिए करना है, तो यहां नया प्रोजेक्ट बनाएं.

3. Cloud Shell Editor खोलें

1. सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
2. अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
3. अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
   • देखें पर क्लिक करें
   • टर्मिनल पर क्लिक करें
4. टर्मिनल में, इस कमांड का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:

   gcloud config set project [PROJECT_ID]
   

   • उदाहरण:

     gcloud config set project lab-project-id-example
     

   • अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची देखी जा सकती है:

     gcloud projects list
     

     
5. आपको यह मैसेज दिखेगा:

   Updated property [core/project].
   

   अगर आपको WARNING दिखता है और आपसे Do you want to continue (Y/n)? पूछा जाता है, तो इसका मतलब है कि आपने प्रोजेक्ट आईडी गलत डाला है. n दबाएं, Enter दबाएं, और gcloud config set project निर्देश को फिर से चलाने की कोशिश करें.

4. एपीआई चालू करें

ऐप्लिकेशन कॉम्पोनेंट को डिप्लॉय करने और Google Cloud Assist का इस्तेमाल करने के लिए, इन एपीआई को चालू करें:

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

टर्मिनल में, इन एपीआई को चालू करें:

```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. प्रोजेक्ट तैयार करना

Cloud Assist को टेस्ट करने के लिए, आपको बुनियादी ऐप्लिकेशन और डिप्लॉयमेंट बनाना होगा.

डायरेक्ट्री बनाना

1. Cloud Shell Editor या अपने पसंदीदा डेवलपर एनवायरमेंट को खोलें.
2. नया फ़ोल्डर बनाने के लिए:

   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. Cloud Shell Editor वर्कस्पेस खोलने के लिए, टर्मिनल में यह कमांड चलाएं:

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

ऐसा करने पर, अगर टर्मिनल बंद हो जाता है, तो इसे फिर से खोलने के लिए, सबसे ऊपर मौजूद मेन्यू में व्यू और फिर टर्मिनल पर क्लिक करें.

फ़ाइलें बनाना

अब ऐप्लिकेशन के लिए ज़रूरी स्टार्टर फ़ाइलें बनाएं.

1. टर्मिनल में यह कमांड चलाकर, Dockerfile बनाएं. यह फ़ाइल, ऐप्लिकेशन कंटेनर बनाने का काम करती है.

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. टर्मिनल में यहां दिया गया कमांड चलाकर, main.py फ़ाइल बनाएं. इस फ़ाइल में 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. टर्मिनल में यहां दिया गया कमांड चलाकर, requirements.txt फ़ाइल बनाएं. यह फ़ाइल, 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. टर्मिनल में यहां दिया गया कमांड चलाकर, main.tf फ़ाइल बनाएं. यह फ़ाइल, बनाए जाने वाले Google Cloud संसाधनों को मैनेज करती है.

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. टर्मिनल में यहां दिया गया कमांड चलाकर, variables.tf फ़ाइल बनाएं. यह फ़ाइल, Google Cloud के संसाधनों के लिए Terraform वैरिएबल को मैनेज करती है.

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. टर्मिनल में यहां दिया गया कमांड चलाकर, setup_via_tf.sh फ़ाइल बनाएं. यह फ़ाइल, 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. शेल स्क्रिप्ट को एक्ज़ीक्यूटेबल बनाने के लिए, यह कमांड चलाएं:

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

8. डप्लॉयमेंट के लिए, अपने Google Cloud प्रोजेक्ट आईडी वाली .env फ़ाइल बनाएं. YOUR_PROJECT_ID फ़ील्ड को अपडेट करें:

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

6. ऐप्लिकेशन डिप्लॉय करना

ऐप्लिकेशन कोड और Google Cloud संसाधन डिप्लॉय करने के लिए तैयार हैं. इसमें 15 मिनट लग सकते हैं.

टर्मिनल में यह कमांड चलाएं:

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

कॉम्पोनेंट डिप्लॉय होने के दौरान, Cloud Shell Editor में फ़ाइलें ब्राउज़ करके ज़्यादा जानें.

7. गड़बड़ी बनाना और उसे डीबग करना

अब हम ऐप्लिकेशन से गड़बड़ी ट्रिगर करेंगे. बाईं ओर मौजूद पैनल में, Cloud Run खोलें. इसके बाद, auth-issue-demo सेवा पर क्लिक करें.

1. सेवा की जानकारी पेज पर सबसे ऊपर एक यूआरएल होता है. यूआरएल कॉपी करें और ब्राउज़र का नया टैब खोलें. यूआरएल चिपकाएं और उसमें /connect जोड़ें. आपका यूआरएल कुछ ऐसा दिखेगा:

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

2. यूआरएल पर जाएं. Cloud Run इंस्टेंस को शुरू होने में कुछ सेकंड लग सकते हैं. आपको गड़बड़ी का मैसेज मिलेगा.
3. Cloud Run की सेवा से जुड़ी ज़्यादा जानकारी वाले पेज पर वापस जाएं. Observability पर क्लिक करें. इसके बाद, Logs पर क्लिक करें. आपको कंटेनर के लॉग दिखेंगे. इनमें गड़बड़ी की जानकारी भी शामिल होगी. अगर गड़बड़ी का लॉग अभी तक उपलब्ध नहीं है, तो कुछ सेकंड इंतज़ार करें. इसके बाद, सबसे ऊपर दाईं ओर मौजूद आइकॉन का इस्तेमाल करके पेज को रीफ़्रेश करें.
4. ज़्यादा जानने के लिए, गड़बड़ी के लॉग पर क्लिक करें. मुख्य लॉग की लाइन में मौजूद, जांच करें आइकॉन पर क्लिक करें. इसके बाद, लॉग की जांच करें पर क्लिक करें

इसके बाद, Cloud Assist का चैट पैनल खुल जाएगा. जांच पूरी होने में दो से तीन मिनट लगते हैं.

जांच पूरी होने के बाद, नतीजे और सुझाव पढ़े जा सकते हैं. Cloud Run को AlloyDB इंस्टेंस ऐक्सेस करने की अनुमति देने के लिए, सेवा खाते में सही अनुमति जोड़ने का सुझाव दिया गया है.

8. गड़बड़ी ठीक करना

सेवा खाते की अनुमति से जुड़ी गड़बड़ी को ठीक करें.

1. Cloud IAM पर जाएं.
2. ऐक्सेस दें बटन पर क्लिक करें. प्रिंसिपल पैन में, auth-demo टाइप करें और सेवा खाते के दिखने का इंतज़ार करें.
3. इसके बाद, सेवा खाते में AlloyDB Client भूमिका जोड़ें. इसके बाद, सेव करें पर क्लिक करें.

इसमें एक मिनट तक लग सकता है.

कुछ समय बाद, ऐप्लिकेशन को रीफ़्रेश करें. अब आपको AlloyDB डेटाबेस से, 'हो गया' मैसेज दिखेगा.

9. बधाई हो

बधाई हो! आपने Cloud Investigations के बारे में जानकारी देने वाला यह मॉड्यूल पूरा कर लिया है. साथ ही, आपने Google Cloud पर किसी ऐप्लिकेशन की अनुमतियों को डीबग करने की प्रोसेस भी पूरी कर ली है.

आगे क्या करना है?

• अलग-अलग स्थितियों में Gemini Cloud Assist का इस्तेमाल करने के तरीके के बारे में बताने वाली अन्य गाइड और उदाहरण देखें:
  • Google Cloud में Gemini से जुड़ी समस्याएं हल करना
  • Google Cloud में Gemini की मदद से नया ऐप्लिकेशन डिज़ाइन और डिप्लॉय करना
• इसकी सुविधाओं और क्षमताओं के बारे में ज़्यादा जानने के लिए, Gemini Cloud Assist का दस्तावेज़ पढ़ें.