Gemini CLI-Sicherheitserweiterung für GitHub-PR-Reviews verwenden

1. Einführung

Die Gemini CLI Security Extension ist eine von Google entwickelte Open-Source-Gemini CLI-Erweiterung, die Code auf Sicherheitsrisiken und ‑schwachstellen analysiert. Sie können die Security-Erweiterung mit der Gemini CLI verwenden, um Sicherheitslücken lokal zu identifizieren, genau wie mit jeder anderen Gemini CLI-Erweiterung. Sie können ihn auch aufrufen, um Pull-Anfragen auf GitHub zu prüfen. In diesem Codelab erfahren Sie, wie Sie die Sicherheitserweiterung in Ihrem GitHub-Repository verwenden.

Aufgaben

Sichere Authentifizierung von GitHub bei Google Cloud konfigurieren
GitHub Actions-Workflow erstellen, der die Gemini CLI Security Extension aufruft
Sicherheitsüberprüfung für eine neue oder vorhandene PR mit GitHub Actions ausführen

Lerninhalte

Workload Identity-Föderation für die sichere Authentifizierung von GitHub Actions bei Google Cloud verwenden
Vorteile der Verwendung eines Workload Identity-Pools und eines Workload Identity-Anbieters anstelle eines Gemini API-Schlüssels für die Authentifizierung
Sicherheitsüberprüfung mit Pull-Requests durchführen
Sicherheitsüberprüfungen der Sicherheitserweiterung interpretieren

Voraussetzungen

Webbrowser
Ein GitHub-Konto und ein Repository
Ein Google Cloud-Projekt

Dieses Codelab richtet sich an Entwickler, die mit dem CI/CD-Workflow auf GitHub vertraut sind. Sie müssen sich nicht mit der Gemini CLI oder Gemini CLI-Erweiterungen auskennen. Wenn Sie mehr über die Funktionsweise von Erweiterungen erfahren möchten, sehen Sie sich das Codelab Erste Schritte mit Gemini CLI-Erweiterungen an.

In diesem Codelab erfahren Sie, wie Sie die Gemini CLI Security Extension in Ihrem GitHub-Repository einrichten. Wir schlagen keinen Code vor, mit dem Sie einen PR für Ihr Repository öffnen können, um eine Sicherheitslücke zu finden.

2. Hinweis

Projekt erstellen oder auswählen

Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
Die Abrechnung für das Cloud-Projekt muss aktiviert sein. Weitere Informationen
Öffnen Sie Cloud Shell, eine Befehlszeilenumgebung, die in Google Cloud ausgeführt wird. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.

Bild der Schaltfläche „Cloud Shell aktivieren“

Prüfen Sie nach der Verbindung mit Cloud Shell mit dem folgenden Befehl, ob Sie authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:

gcloud auth list

Führen Sie den folgenden Befehl aus, um zu bestätigen, dass der Befehl gcloud für die Verwendung Ihres Projekts konfiguriert ist.

gcloud config list project

Wenn Ihr Projekt nicht festgelegt ist, verwenden Sie den folgenden Befehl, um es festzulegen:

gcloud config set project ${GOOGLE_CLOUD_PROJECT}

3. Authentifizierung von GitHub zu Google Cloud einrichten

Funktionsweise

GitHub Actions-Workflow

Die Identitätsföderation von Arbeitslasten ist die empfohlene Methode zur Authentifizierung bei Google Cloud über GitHub Actions.

Für jeden Workflow Lauf Job von GitHub Actions gibt GitHub als externer Identitätsanbieter ein signiertes JWT (JSON Web Token) aus. Dieses Token enthält „Claims“ wie repository, workflow und job_workflow_ref, die als digitaler Ausweis für den jeweiligen Läufer dienen. In diesem Lab erstellen Sie einen GitHub Actions-Workflow mit einem Job, der die Aktion google-github-actions/run-gemini-cli verwendet. Dadurch wird ein JWT von GitHub angefordert und dieses Token an den Security Token Service (STS) in Google Cloud gesendet.
Sie konfigurieren einen Workload Identity-Pool und einen Anbieter in Google Cloud, indem Sie die Aussteller-URL auf die offizielle GitHub-Token-Dienst-URL https://token.actions.githubusercontent.com festlegen und Ihre Attributzuordnungen definieren, die in der Regel Repository- und Zweignamen enthalten. Google Cloud STS validiert das JWT anhand der Workload Identity-Pool-Regeln. Wenn alles, einschließlich der Attributzuordnungen, in Ordnung ist, tauscht der STS das GitHub-Token gegen ein kurzlebiges Google Cloud Federated Access Token ein.
Jetzt kann die Aktion google-github-actions/run-gemini-cli in Ihrem GitHub Actions-Workflow das kurzlebige Google Cloud Federated Access Token verwenden, um die Identität eines verbundenen Dienstkontos für den Workload Identity-Pool zu übernehmen. Das verbundene Dienstkonto muss die erforderlichen IAM-Rollen und ‑Berechtigungen für den Zugriff auf Google Cloud-Ressourcen und ‑Dienste haben.
GitHub verwendet direkte Identitätsföderation ohne Dienstkonto-Identitätsübernahme. Für die Gemini CLI ist jedoch die Erstellung eines Dienstkontotokens erforderlich, was nur über die Identitätsübernahme für Dienstkonten unterstützt wird.

Vorteile der Verwendung der Workload Identity-Föderation gegenüber dem Gemini API-Schlüssel

Es ist möglich, Gemini CLI-Aufrufe, die von GitHub Actions stammen, mit einem Gemini API-Schlüssel zu authentifizieren. Dazu müssen Sie ein neues GitHub Actions-Secret mit dem Namen GEMINI_API_KEY mit dem entsprechenden Schlüsselwert erstellen. Aus den folgenden Sicherheitsgründen wird dies jedoch nicht empfohlen:

Gemini-API-Schlüssel können über die entsprechenden IAM-Rollenbindungen weitreichende Berechtigungen haben. Wenn sie manipuliert werden, ermöglichen sie den Zugriff auf eine Vielzahl von Google Cloud-Ressourcen und -Diensten. Bei der Workload Identity-Föderation werden Dienstkonten und kurzlebige Zugriffstokens verwendet, was die Authentifizierung erheblich sicherer macht.
Auch die Verwaltung von Gemini API-Schlüsseln im großen Maßstab ist schwierig. Es dauert einige Zeit, bis Sie herausgefunden haben, welche Workflows einen offengelegten Schlüssel verwenden. Auch das manuelle Rotieren der Schlüssel kostet Zeit. Andererseits können Sie Workload Identity-Pools und ‑Anbieter, die mit Ihrem Repository verknüpft sind, ganz einfach in der Cloud Console aufrufen, bearbeiten und löschen.
Bei Gemini-API-Schlüsseln müssen Sie immer darauf achten, dass Sie sie nicht versehentlich in Zugriffs- oder Debugging-Logs offenlegen. Bei der Identitätsföderation von Arbeitslasten werden keine Secrets für GitHub Actions-Workflows, sondern Variablen gespeichert, die von Natur aus weniger vertraulich sind.

GitHub Actions und Google Cloud konfigurieren

Melden Sie sich in Cloud Shell in Ihrem GitHub-Konto an.

gh auth login

Erstellen Sie eine neue Datei mit dem Namen setup_workload_identity.sh und kopieren Sie den folgenden Code hinein.
Hinweis: Dies ist eine modifizierte Version des ursprünglichen Skripts aus dem google-github-actions/run-gemini-cli-Repository. Wir haben einen nicht verwendeten internen Dienst cloudcode-pa.googleapis.com und einige redundante IAM-Bindungen für den Prinzipal des Workload Identity-Pools aus dem ursprünglichen Skript entfernt. Wir konfigurieren die Gemini CLI auch für die Verwendung von Vertex AI.

set -e

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Helper functions
print_info() {
    echo -e "${BLUE}ℹ️  $1${NC}"
}

print_success() {
    echo -e "${GREEN}✅ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠️  $1${NC}"
}

print_error() {
    echo -e "${RED}❌ $1${NC}"
}

print_header() {
    echo -e "${BLUE}🚀 $1${NC}"
}

# Default values
GOOGLE_CLOUD_PROJECT=""
GOOGLE_CLOUD_LOCATION="global"
GITHUB_REPO=""
POOL_NAME=""
PROVIDER_NAME=""

# Show help
show_help() {
    cat << EOF
Universal Direct Workload Identity Federation Setup for GitHub Actions

USAGE:
    $0 --repo OWNER/REPO [OPTIONS]

REQUIRED:
    -r, --repo OWNER/REPO       GitHub repository (e.g., google/my-repo)
    -p, --project GOOGLE_CLOUD_PROJECT    Google Cloud project ID

OPTIONS:
    --pool-name NAME           Custom workload identity pool name (default: auto-generated)
    --provider-name NAME       Custom workload identity provider name (default: auto-generated)
    -h, --help                 Show this help

EXAMPLES:
    # Basic setup for a repository
    $0 --repo google/my-repo --project my-gcp-project

    # Custom pool name
    $0 --repo google/my-repo --project my-gcp-project --pool-name my-pool

    # Custom pool and provider names
    $0 --repo google/my-repo --project my-gcp-project --pool-name my-pool --provider-name my-provider

ABOUT DIRECT WORKLOAD IDENTITY FEDERATION:
    This script sets up Direct Workload Identity Federation (preferred method).
    - No intermediate service accounts required
    - Direct authentication from GitHub Actions to GCP resources
    - Maximum token lifetime of 10 minutes
    - You grant permissions directly to the Workload Identity Pool on GCP resources

EOF
}

# Parse command line arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -r|--repo)
            GITHUB_REPO="$2"
            shift 2
            ;;
        -p|--project)
            GOOGLE_CLOUD_PROJECT="$2"
            shift 2
            ;;
        --pool-name)
            POOL_NAME="$2"
            shift 2
            ;;
        --provider-name)
            PROVIDER_NAME="$2"
            shift 2
            ;;
        -l|--location)
            GOOGLE_CLOUD_LOCATION="$2"
            shift 2
            ;;
        -h|--help)
            show_help
            exit 0
            ;;
        *)
            print_error "Unknown option: $1"
            echo "Use --help for usage information."
            exit 1
            ;;
    esac
done

# Validate required arguments
if [[ -z "${GITHUB_REPO}" ]]; then
    print_error "Repository is required. Use --repo OWNER/REPO"
    echo ""
    echo "💡 To find your repository name:"
    echo "   1. Go to your GitHub repository"
    echo "   2. The URL shows: https://github.com/OWNER/REPOSITORY"
    echo "   3. Use: OWNER/REPOSITORY (e.g., google/golang)"
    echo ""
    echo "Use --help for usage information."
    exit 1
fi
if [[ -z "${GOOGLE_CLOUD_PROJECT}" ]]; then
    print_error "GCP project is required. Use --project GOOGLE_CLOUD_PROJECT"
    echo ""
    echo "💡 To find your project ID:"
    echo "   1. Go to your Google Cloud console"
    echo "   2. The URL displays: https://console.cloud.google.com/welcome?project=GOOGLE_CLOUD_PROJECT"
    echo ""
    echo "Use --help for usage information."
    exit 1
fi

# Validate repository format
if [[ ! "${GITHUB_REPO}" =~ ^[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+$ ]]; then
    print_error "Invalid repository format '${GITHUB_REPO}'"
    echo "Expected format: owner/repo (e.g., google/my-repo)"
    exit 1
fi

# Extract repository components
REPO_OWNER=$(echo "${GITHUB_REPO}" | cut -d'/' -f1)

# Generate unique names based on repository
REPO_HASH_INPUT=$(echo -n "${GITHUB_REPO}")
REPO_HASH_SHA=$(echo "${REPO_HASH_INPUT}" | shasum -a 256)
REPO_HASH=$(echo "${REPO_HASH_SHA}" | cut -c1-8)

# Use custom pool name if provided, otherwise generate one
if [[ -z "${POOL_NAME}" ]]; then
    POOL_NAME="github-${REPO_HASH}"
fi

# Use custom provider name if provided, otherwise generate one
if [[ -z "${PROVIDER_NAME}" ]]; then
    PROVIDER_NAME="gh-${REPO_HASH}"
fi

print_header "Starting Direct Workload Identity Federation setup"
echo "📦 Repository: ${GITHUB_REPO}"
echo "☁️ Project: ${GOOGLE_CLOUD_PROJECT}"
echo "🏊 Pool: ${POOL_NAME}"
echo "🆔 Provider: ${PROVIDER_NAME}"
echo ""

# Verify gcloud authentication
print_info "Verifying gcloud authentication..."
GCLOUD_AUTH_LIST_RAW=$(gcloud auth list --filter=status:ACTIVE --format="value(account)")
GCLOUD_AUTH_LIST=$(echo "${GCLOUD_AUTH_LIST_RAW}" | head -1)
if [[ -z "${GCLOUD_AUTH_LIST}" ]]; then
    print_error "No active gcloud authentication found"
    echo "Please run: gcloud auth login"
    exit 1
fi

# Test project access
if ! gcloud projects describe "${GOOGLE_CLOUD_PROJECT}" > /dev/null 2>&1; then
    print_error "Cannot access project '${GOOGLE_CLOUD_PROJECT}'"
    echo "Please verify:"
    echo "  1. Project ID is correct"
    echo "  2. You have permissions on this project"
    echo "  3. Project exists and is not deleted"
    exit 1
fi

print_success "Authentication and project access verified"

# Step 1: Enable required APIs
print_header "Step 1: Enabling required Google Cloud APIs"
required_apis=(
    "aiplatform.googleapis.com"
    "cloudaicompanion.googleapis.com"
    "cloudresourcemanager.googleapis.com"
    "cloudtrace.googleapis.com"
    "iam.googleapis.com"
    "iamcredentials.googleapis.com"
    "logging.googleapis.com"
    "monitoring.googleapis.com"
    "sts.googleapis.com"
)
gcloud services enable "${required_apis[@]}" --project="${GOOGLE_CLOUD_PROJECT}"
print_success "APIs enabled successfully."

# Step 2: Create Workload Identity Pool
print_header "Step 2: Creating Workload Identity Pool"

if ! gcloud iam workload-identity-pools describe "${POOL_NAME}" \
    --project="${GOOGLE_CLOUD_PROJECT}" \
    --location="${GOOGLE_CLOUD_LOCATION}" &> /dev/null; then
    print_info "Creating Workload Identity Pool: ${POOL_NAME}"
    gcloud iam workload-identity-pools create "${POOL_NAME}" \
        --project="${GOOGLE_CLOUD_PROJECT}" \
        --location="${GOOGLE_CLOUD_LOCATION}" \
        --display-name="GitHub Actions Pool"
    print_success "Workload Identity Pool created"
else
    print_info "Workload Identity Pool '${POOL_NAME}' exists. Verifying state..."
    # Fetch the current state of the existing pool.
    POOL_STATE=$(gcloud iam workload-identity-pools describe "${POOL_NAME}" \
        --project="${GOOGLE_CLOUD_PROJECT}" \
        --location="${GOOGLE_CLOUD_LOCATION}" \
        --format="value(state)")

    if [[ "${POOL_STATE}" == "ACTIVE" ]]; then
        # Pool exists and is in the correct state.
        print_success "Workload Identity Pool already exists and is ACTIVE."
    else
        if [[ "${POOL_STATE}" == "DELETED" ]]; then
        # Pool exists but is DELETED. Undelete the pool. 
        print_warning "Workload Identity Pool already exists but is in a DELETED state. Running 'undelete'."
        gcloud iam workload-identity-pools undelete "${POOL_NAME}" \
            --project="${GOOGLE_CLOUD_PROJECT}" \
            --location="${GOOGLE_CLOUD_LOCATION}"
        else
        # Pool exists but is in an unexpected state.
        print_error "Pool '${POOL_NAME}' is in an unexpected state: '${POOL_STATE}'. Expected states are: {'ACTIVE', 'DELETED'}. Exiting"
        exit 1

        fi
    fi
fi

# Get the pool ID
WIF_POOL_ID=$(gcloud iam workload-identity-pools describe "${POOL_NAME}" \
    --project="${GOOGLE_CLOUD_PROJECT}" \
    --location="${GOOGLE_CLOUD_LOCATION}" \
    --format="value(name)")

# Step 3: Create Workload Identity Provider
print_header "Step 3: Creating Workload Identity Provider"
ATTRIBUTE_CONDITION="assertion.repository_owner == '${REPO_OWNER}'"

if ! gcloud iam workload-identity-pools providers describe "${PROVIDER_NAME}" \
    --project="${GOOGLE_CLOUD_PROJECT}" \
    --location="${GOOGLE_CLOUD_LOCATION}" \
    --workload-identity-pool="${POOL_NAME}" &> /dev/null; then
    print_info "Creating Workload Identity Provider: ${PROVIDER_NAME}"
    gcloud iam workload-identity-pools providers create-oidc "${PROVIDER_NAME}" \
        --project="${GOOGLE_CLOUD_PROJECT}" \
        --location="${GOOGLE_CLOUD_LOCATION}" \
        --workload-identity-pool="${POOL_NAME}" \
        --display-name="${PROVIDER_NAME}" \
        --attribute-mapping="google.subject=assertion.sub,attribute.actor=assertion.actor,attribute.repository=assertion.repository,attribute.repository_owner=assertion.repository_owner" \
        --attribute-condition="${ATTRIBUTE_CONDITION}" \
        --issuer-uri="https://token.actions.githubusercontent.com"
    print_success "Workload Identity Provider created"
else
    print_info "Workload Identity Provider '${PROVIDER_NAME}' exists. Verifying state..."
    # Fetch the current state of the existing provider.
    PROVIDER_STATE=$(gcloud iam workload-identity-pools providers describe "${PROVIDER_NAME}" \
        --project="${GOOGLE_CLOUD_PROJECT}" \
        --location="${GOOGLE_CLOUD_LOCATION}" \
        --workload-identity-pool="${POOL_NAME}" \
        --format="value(state)")

    if [[ "${PROVIDER_STATE}" == "ACTIVE" ]]; then
        # Provider exists and is in the correct state.
        print_success "Workload Identity Provider already exists and is ACTIVE."
    else
        if [[ "${PROVIDER_STATE}" == "DELETED" ]]; then
        # Provider exists but is DELETED. Undelete the provider. 
        print_warning "Workload Identity Provider already exists but is in a DELETED state. Running 'undelete'."
        gcloud iam workload-identity-pools providers undelete "${PROVIDER_NAME}" \
            --project="${GOOGLE_CLOUD_PROJECT}" \
            --location="${GOOGLE_CLOUD_LOCATION}" \
            --workload-identity-pool="${POOL_NAME}"
        else
        # Provider exists but is in an unexpected state.
        print_error "Provider '${PROVIDER_NAME}' is in an unexpected state: '${PROVIDER_STATE}'. Expected states are: {'ACTIVE', 'DELETED'}. Exiting"
        exit 1

        fi
    fi
fi

# Step 4: Grant required permissions to the Workload Identity Pool
print_header "Step 4: Granting required permissions to Workload Identity Pool"
PRINCIPAL_SET="principalSet://iam.googleapis.com/${WIF_POOL_ID}/attribute.repository/${GITHUB_REPO}"

print_info "Skipped: Granting required permissions directly to the Workload Identity Pool..."

# Step 5: Create and Configure Service Account for Gemini CLI
print_header "Step 5: Create and Configure Service Account for Gemini CLI"
SERVICE_ACCOUNT_NAME="gemini-cli-${REPO_HASH}"
SERVICE_ACCOUNT_EMAIL="${SERVICE_ACCOUNT_NAME}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com"

# Create service account if it doesn't exist
if ! gcloud iam service-accounts describe "${SERVICE_ACCOUNT_EMAIL}" --project="${GOOGLE_CLOUD_PROJECT}" &> /dev/null; then
    print_info "Creating Service Account: ${SERVICE_ACCOUNT_NAME}"
    gcloud iam service-accounts create "${SERVICE_ACCOUNT_NAME}" \
        --project="${GOOGLE_CLOUD_PROJECT}" \
        --display-name="Gemini CLI Service Account"
    print_success "Service Account created: ${SERVICE_ACCOUNT_EMAIL}"
else
    print_success "Service Account already exists: ${SERVICE_ACCOUNT_EMAIL}"
fi

# Grant permissions to the service account on the project
print_info "Granting 'Cloud AI Companion User' role to Service Account..."
gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/cloudaicompanion.user" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Allow the service account to generate an access tokens
print_info "Granting 'Service Account Token Creator' role to Service Account..."

gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/iam.serviceAccountTokenCreator" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Grant logging permissions to the service account
print_info "Granting 'Logging Writer' role to Service Account..."
gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/logging.logWriter" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Grant monitoring permissions to the service account
print_info "Granting 'Monitoring Editor' role to Service Account..."
gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/monitoring.editor" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Grant tracing permissions to the service account
print_info "Granting 'Cloud Trace Agent' role to Service Account..."
gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/cloudtrace.agent" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Grant Vertex AI permissions to the service account
print_info "Granting 'Vertex AI User' role to Service Account..."
gcloud projects add-iam-policy-binding "${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/aiplatform.user" \
    --member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --condition=None

# Allow the Workload Identity Pool to impersonate the Service Account
print_info "Allowing GitHub Actions from '${GITHUB_REPO}' to impersonate the Service Account..."
gcloud iam service-accounts add-iam-policy-binding "${SERVICE_ACCOUNT_EMAIL}" \
    --project="${GOOGLE_CLOUD_PROJECT}" \
    --role="roles/iam.workloadIdentityUser" \
    --member="${PRINCIPAL_SET}"

print_success "GitHub Actions can now impersonate ${SERVICE_ACCOUNT_NAME}"

# Get the full provider name for output
WIF_PROVIDER_FULL=$(gcloud iam workload-identity-pools providers describe "${PROVIDER_NAME}" \
    --project="${GOOGLE_CLOUD_PROJECT}" \
    --location="${GOOGLE_CLOUD_LOCATION}" \
    --workload-identity-pool="${POOL_NAME}" \
    --format="value(name)")


# Step 6: Output configuration

print_header "🎉 Setup Complete!"
echo ""
print_success "Direct Workload Identity Federation has been configured for your repository!"
echo ""

print_header "Permissions Granted"
echo ""
print_success "The following permissions have been automatically granted to your repository:"
echo "• roles/logging.logWriter - Write logs to Cloud Logging"
echo "• roles/monitoring.editor - Create and update metrics in Cloud Monitoring"
echo "• roles/cloudtrace.agent - Send traces to Cloud Trace"
echo "• roles/aiplatform.user - Use Vertex AI for model inference"

echo ""
print_success "A Service Account (${SERVICE_ACCOUNT_EMAIL}) was created with the following roles:"
echo "• roles/cloudaicompanion.user - Use Code Assist for model inference"
echo "• roles/iam.serviceAccountTokenCreator"
echo ""


# Check for `gh` CLI and set variables automatically if available
if command -v gh &> /dev/null; then
    print_info "The 'gh' CLI is installed. Setting variables automatically..."

    gh variable set GCP_WIF_PROVIDER --body "${WIF_PROVIDER_FULL}" --repo "${GITHUB_REPO}"
    gh variable set GOOGLE_CLOUD_PROJECT --body "${GOOGLE_CLOUD_PROJECT}" --repo "${GITHUB_REPO}"
    gh variable set GOOGLE_CLOUD_LOCATION --body "${GOOGLE_CLOUD_LOCATION}" --repo "${GITHUB_REPO}"
    gh variable set SERVICE_ACCOUNT_EMAIL --body "${SERVICE_ACCOUNT_EMAIL}" --repo "${GITHUB_REPO}"
    gh variable set GOOGLE_GENAI_USE_VERTEXAI --body "true" --repo "${GITHUB_REPO}"

    print_success "GitHub variables have been set automatically!"
else
    print_warning "The 'gh' CLI was not found. Either install it and rerun this script OR set the below variables manually."
    echo "  For manual setup, go to https://github.com/${GITHUB_REPO}/settings/variables/actions and add the following repository variables:"
    echo ""
    echo "🔑 Variable Name: GCP_WIF_PROVIDER"
    echo "   Variable Value: ${WIF_PROVIDER_FULL}"
    echo ""
    echo "☁️  Variable Name: GOOGLE_CLOUD_PROJECT"
    echo "   Variable Value: ${GOOGLE_CLOUD_PROJECT}"
    echo ""
    echo "☁️ Variable Name: GOOGLE_CLOUD_LOCATION"
    echo "   Variable Value: ${GOOGLE_CLOUD_LOCATION}"
    echo ""
    echo "☁️ Variable Name: SERVICE_ACCOUNT_EMAIL"
    echo "   Variable Value: ${SERVICE_ACCOUNT_EMAIL}"
    echo ""
fi

print_success "Setup completed successfully! 🚀"

Machen Sie das Skript ausführbar.

chmod +x setup_workload_identity.sh

Führen Sie das Skript aus.

./setup_workload_identity.sh --repo {OWNER/REPO} --project {GOOGLE_CLOUD_PROJECT}

4. GitHub Actions-Workflow erstellen

Sie können ein GitHub-Repository auschecken, das Ihnen gehört.

git clone {YOUR_REPO}
cd {YOUR REPO}

Erstellen Sie einen GitHub Actions-Workflow, der den Slash-Befehl /security:analyze-github-pr aufruft, indem Sie ein Beispiel-Workflow-yml-Script aus dem /gemini-cli-extensions/security-Repository kopieren.

git checkout -b workflow
mkdir .github/ && cd .github/
mkdir workflows/ && cd workflows/
curl -L https://raw.githubusercontent.com/gemini-cli-extensions/security/refs/heads/main/.github/workflows/gemini-review.yml -o gemini-review.yml

Übertragen Sie den GitHub Actions-Workflow per Push an Ihren Remote-Ursprung auf GitHub.

git add .github/workflows/gemini-review.yml
git commit -m "add new gha workflow"
git push --set-upstream origin workflow

5. Workflow für Sicherheitsanalysen für neue und vorhandene Pull-Requests ausführen

Starten Sie einen neuen PR in Ihrem GitHub-Repository oder posten Sie als Repository-Inhaber oder Mitwirkender einen neuen Kommentar @gemini-cli /review. Dadurch wird eine Sicherheitsüberprüfung des Pull-Requests gestartet. Die Gemini CLI-Sicherheitserweiterung aus dem GitHub Actions-Workflow, den Sie in Ihrem Repository committet haben, kennzeichnet alle gefundenen Sicherheitsprobleme nach Schweregradkategorien von „Kritisch“ über „Hoch“ und „Mittel“ bis „Niedrig“.

Hier finden Sie ein Beispiel für eine Sicherheitsüberprüfung eines neuen PR und ein Beispiel für eine Sicherheitsüberprüfung eines vorhandenen PR.

6. Weitere Informationen

Wir empfehlen Ihnen, die wachsende Liste benutzerdefinierter Befehle mit neuen Sicherheitsfunktionen in der Gemini CLI-Sicherheitserweiterung zu nutzen und sie in Ihren Workflows zu verwenden. Beispiel:

/security:scan-deps verweist auf die Abhängigkeiten Ihres Projekts in OSV.dev.

In den Versionshinweisen findest du Informationen zu den neuesten Funktionen und Fehlerkorrekturen.

7. Glückwunsch

Sie haben Ihr GitHub-Repository erfolgreich für die Verwendung der Gemini CLI Security Extension konfiguriert, um Pull-Anfragen auf Sicherheitsrisiken und ‑lücken zu analysieren.