Korzystanie z rozszerzenia zabezpieczeń interfejsu wiersza poleceń Gemini do sprawdzania żądań pull na GitHubie

1. Wprowadzenie

Rozszerzenie zabezpieczeń interfejsu wiersza poleceń Gemini to opracowany przez Google dodatek do interfejsu wiersza poleceń Gemini o otwartym kodzie źródłowym, który analizuje kod pod kątem zagrożeń i luk w zabezpieczeniach. Rozszerzenia Security możesz używać z interfejsem wiersza poleceń Gemini do lokalnego identyfikowania problemów z bezpieczeństwem, tak jak w przypadku każdego innego dodatku do interfejsu wiersza poleceń Gemini. Możesz też używać go do sprawdzania żądań pull w GitHubie. W tym ćwiczeniu dowiesz się, jak korzystać z rozszerzenia Security w repozytorium GitHub.

Co musisz zrobić

Konfigurowanie bezpiecznego uwierzytelniania z GitHuba w Google Cloud
Tworzenie przepływu pracy GitHub Actions, który wywołuje rozszerzenie zabezpieczeń interfejsu wiersza poleceń Gemini
Przeprowadzanie kontroli zabezpieczeń w nowym lub istniejącym żądaniu pull za pomocą GitHub Actions

Czego się nauczysz

Jak używać federacji tożsamości zadań do bezpiecznego uwierzytelniania z GitHub Actions w Google Cloud
Poznaj zalety korzystania z puli tożsamości zadań i dostawcy tożsamości do Workload Identity zamiast klucza interfejsu Gemini API na potrzeby uwierzytelniania.
Jak przeprowadzić kontrolę zabezpieczeń za pomocą żądań scalenia
Jak interpretować wyniki kontroli bezpieczeństwa zwracane przez rozszerzenie Security

Czego potrzebujesz

przeglądarki internetowej,
konto i repozytorium GitHub,
projekt Google Cloud,

To ćwiczenie jest przeznaczone dla deweloperów, którzy znają przepływ pracy CI/CD w GitHubie. Nie musisz znać interfejsu wiersza poleceń Gemini ani jego rozszerzeń. Jeśli chcesz dowiedzieć się, jak działają rozszerzenia, zapoznaj się z tym przewodnikiem: Getting Started with Gemini CLI Extensions (w języku angielskim).

Z tego ćwiczenia dowiesz się, jak skonfigurować w repozytorium GitHub rozszerzenie zabezpieczeń interfejsu wiersza poleceń Gemini. Nie będziemy sugerować kodu, który pozwoli Ci otworzyć żądanie pull w Twoim repozytorium, aby wywołać wykrycie luki w zabezpieczeniach.

2. Zanim zaczniesz

Utwórz lub wybierz projekt

W konsoli Google Cloud na stronie selektora projektu wybierz lub utwórz projekt w chmurze Google Cloud.
Sprawdź, czy w projekcie Cloud włączone są płatności. Dowiedz się, jak zweryfikować rozliczenia.
Otwórz Cloud Shell, czyli środowisko wiersza poleceń działające w Google Cloud. Kliknij Aktywuj Cloud Shell u góry konsoli Google Cloud.

Obraz przycisku aktywowania Cloud Shell

Po połączeniu z Cloud Shell sprawdź, czy uwierzytelnianie zostało przeprowadzone, a projekt jest ustawiony na Twój identyfikator projektu, używając tego polecenia:

gcloud auth list

Aby sprawdzić, czy polecenie gcloud jest skonfigurowane do używania Twojego projektu, uruchom to polecenie:

gcloud config list project

Jeśli projekt nie jest ustawiony, użyj tego polecenia, aby go ustawić:

gcloud config set project ${GOOGLE_CLOUD_PROJECT}

3. Konfigurowanie uwierzytelniania z GitHuba w Google Cloud

Jak to działa

Przepływ pracy Działań na GitHubie

Federacja tożsamości zadań to zalecany sposób uwierzytelniania w Google Cloud z poziomu GitHub Actions.

W przypadku każdego przepływu pracy uruchomionego zadania w ramach Działań na GitHubie GitHub jako zewnętrzny dostawca tożsamości wydaje podpisany token JWT (token sieciowy JSON). Ten token zawiera „deklaracje”, takie jak repository, workflow i job_workflow_ref, które działają jak cyfrowy dowód tożsamości danego biegacza. W tym module utworzysz przepływ pracy GitHub Actions z zadaniem, które korzysta z działania google-github-actions/run-gemini-cli. To działanie wyśle do GitHuba żądanie tokena JWT i prześle ten token do usługi Security Token Service (STS) w Google Cloud.
W Google Cloud skonfigurujesz pulę tożsamości zadań i dostawcę, ustawiając adres URL wystawcy na oficjalny adres URL usługi tokenów GitHub https://token.actions.githubusercontent.com i definiując „Mapowania atrybutów”, które zwykle obejmują nazwy repozytorium i gałęzi. Usługa Google Cloud STS weryfikuje JWT na podstawie reguł puli tożsamości zadań. Jeśli wszystko się zgadza, w tym mapowania atrybutów, usługa STS wymienia token GitHub na krótkotrwały token dostępu federacyjnego Google Cloud.
Teraz działanie google-github-actions/run-gemini-cli w przepływie pracy GitHub Actions może używać krótkotrwałego tokena dostępu sfederowanego Google Cloud, aby „przyjmować tożsamość” połączonego konta usługi w puli tożsamości zadań. Połączone konto usługi musi mieć niezbędne role uprawnień i uprawnienia dostępu do wszystkich zasobów i usług Google Cloud.
GitHub używa bezpośredniej federacji tożsamości bez przyjmowania tożsamości konta usługi. Interfejs wiersza poleceń Gemini wymaga jednak utworzenia tokena konta usługi, co jest obsługiwane tylko w przypadku przyjmowania tożsamości konta usługi.

Zalety korzystania z federacji tożsamości zadań zamiast klucza interfejsu Gemini API

Wywołania interfejsu wiersza poleceń Gemini pochodzące z GitHub Actions można uwierzytelniać za pomocą klucza interfejsu Gemini API. Wymaga to utworzenia nowego tajnego klucza GitHub Actions o nazwie GEMINI_API_KEY z odpowiednią wartością klucza. Nie jest to jednak zalecane z tych powodów:

Klucze interfejsu Gemini API mogą mieć szerokie uprawnienia wynikające z powiązań z odpowiednimi rolami IAM. W przypadku naruszenia bezpieczeństwa umożliwiają one dostęp do szerokiej gamy zasobów i usług Google Cloud. Federacja tożsamości zadań korzysta z kont usługi i tokenów dostępu o ograniczonym czasie ważności, co znacznie zwiększa bezpieczeństwo autoryzacji.
Klucze interfejsu Gemini API są też trudne do zarządzania na dużą skalę. Określenie, które przepływy pracy używają ujawnionego klucza, zajmuje trochę czasu. Ręczne rotowanie kluczy również zajmuje czas. Z drugiej strony w konsoli Cloud możesz łatwo wyszukiwać, edytować i usuwać pule tożsamości zadań oraz dostawców powiązanych z Twoim repozytorium.
W przypadku kluczy interfejsu Gemini API musisz zawsze sprawdzać, czy nie zostały przypadkowo ujawnione w logach dostępu lub debugowania. W przypadku federacji tożsamości zadań nie przechowujesz żadnych kluczy tajnych przepływów pracy GitHub Actions, tylko zmienne, które są z natury mniej wrażliwe.

Konfigurowanie działań na GitHubie i Google Cloud

W Cloud Shell zaloguj się na konto GitHub.

gh auth login

Utwórz nowy plik setup_workload_identity.sh i skopiuj do niego poniższy kod.
Uwaga: jest to zmodyfikowana wersja oryginalnego skryptu z repozytorium google-github-actions/run-gemini-cli. Z oryginalnego skryptu usunęliśmy nieużywaną usługę wewnętrzną cloudcode-pa.googleapis.com i niektóre zbędne powiązania IAM z podmiotem zabezpieczeń puli tożsamości zadań. Konfigurujemy też interfejs wiersza poleceń Gemini do korzystania z 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! 🚀"

Utwórz z niego plik wykonywalny.

chmod +x setup_workload_identity.sh

Uruchom skrypt.

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

4. Tworzenie przepływu pracy Działań na GitHubie

Sprawdź repozytorium GitHub, którego jesteś właścicielem.

git clone {YOUR_REPO}
cd {YOUR REPO}

Utwórz przepływ pracy GitHub Actions, który wywołuje polecenie po ukośniku /security:analyze-github-pr, kopiując przykładowy skrypt przepływu pracy yml z repozytorium /gemini-cli-extensions/security.

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

Prześlij przepływ pracy Działań na GitHubie do zdalnego źródła w GitHubie.

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

5. Uruchamianie przepływu pracy analizy zabezpieczeń w przypadku nowych i dotychczasowych żądań scalenia

Utwórz nowe żądanie pull w repozytorium GitHub lub opublikuj nowy komentarz „@gemini-cli /review” jako właściciel lub współtwórca repozytorium. Spowoduje to rozpoczęcie sprawdzania bezpieczeństwa w przypadku żądania pull request. Rozszerzenie zabezpieczeń interfejsu wiersza poleceń Gemini z przepływu pracy GitHub Actions, który został zatwierdzony w repozytorium, będzie oznaczać wszelkie znalezione problemy z bezpieczeństwem kategoriami ważności od „Krytyczny”, „Wysoki”, „Średni” do „Niski”.

Oto przykład oceny bezpieczeństwa w przypadku nowej prośby o scalenie i przykład oceny bezpieczeństwa w przypadku istniejącej prośby o scalenie.

6. Dalsze odkrywanie

Zachęcamy do zapoznania się z rosnącą listą poleceń niestandardowych z nowymi funkcjami zabezpieczeń w rozszerzeniu Security interfejsu wiersza poleceń Gemini i do rozpoczęcia korzystania z nich w swoich procesach. Na przykład:

/security:scan-deps porównuje zależności projektu z informacjami na stronie OSV.dev.

Najnowsze funkcje i poprawki błędów znajdziesz w informacjach o wersji.

7. Gratulacje

Gratulacje! Udało Ci się skonfigurować repozytorium GitHub tak, aby używać rozszerzenia Security do interfejsu wiersza poleceń Gemini do analizowania żądań pull pod kątem zagrożeń i luk w zabezpieczeniach.