Google Antigravity ile KCC İşlemlerinde Uzmanlaşma

1. Giriş

Bu codelab'de, IDE'yi artık temsilcilerin öne çıktığı yeni bir döneme taşıyan, ajan tabanlı geliştirme platformu Google Antigravity (belgenin geri kalanında Antigravity olarak anılacaktır) hakkında bilgi edineceksiniz.

Yalnızca satırları otomatik olarak tamamlayan standart kodlama asistanlarının aksine Antigravity, geliştirme sürecinde size yardımcı olmak için planlama, kodlama ve hatta web'de gezinme gibi işlemleri yapabilen bağımsız ajanları yönetmek için "Görev Kontrol Merkezi" sunar.

Antigravity, ajanların öncelikli olduğu bir platform olarak tasarlanmıştır. Bu yaklaşım, yapay zekanın yalnızca kod yazma aracı olmadığını, aynı zamanda karmaşık mühendislik görevlerini planlama, yürütme, doğrulama ve yineleme yeteneğine sahip bağımsız bir aktör olduğunu varsayar. Bu görevler için minimum düzeyde insan müdahalesi gerekir.

Neler öğreneceksiniz?

• Antigravity'yi yükleme ve yapılandırma
• Antigravity'nin temel kavramlarını (ör. Agent Manager, Editor, Browser) keşfetme
• Google Cloud kaynaklarını güvenlik ve uygunlukla yönetmek için sıfırdan üretim düzeyinde bir KCC İşlemleri becerisi oluşturma

Gerekenler

Antigravity şu anda kişisel Gmail hesaplarında önizleme olarak kullanılabilir. Birinci sınıf modelleri kullanmak için ücretsiz kota sunar.

Antigravity'nin sisteminize yerel olarak yüklenmesi gerekir. Ürün Mac, Windows ve belirli Linux dağıtımlarında kullanılabilir. Kendi makinenize ek olarak aşağıdakilere ihtiyacınız olacaktır:

• Gmail hesabı (kişisel Gmail hesabı)
• Google Cloud hesabı ve Google Cloud projesi
• Google Cloud Console ve Cloud Shell'i destekleyen Chrome gibi bir web tarayıcısı

2. Kurulum ve Gereksinimler

Proje kurulumu

Google Cloud projesi oluşturma

1. Google Cloud Console'daki proje seçici sayfasında bir Google Cloud projesi seçin veya oluşturun.
2. Cloud projeniz için faturalandırmanın etkinleştirildiğinden emin olun. Bir projede faturalandırmanın etkin olup olmadığını kontrol etmeyi öğrenin.

Bu codelab, yeni başlayanlar da dahil olmak üzere her seviyeden kullanıcı ve geliştirici için tasarlanmıştır.

3. Kurulum

Antigravity'yi henüz yüklemediyseniz Antigravity'yi yükleyerek başlayalım. Ürün şu anda önizleme aşamasındadır ve kullanmaya başlamak için kişisel Gmail hesabınızı kullanabilirsiniz.

İndirilenler sayfasına gidip durumunuza uygun işletim sistemi sürümünü tıklayın. Uygulama yükleyiciyi başlatın ve uygulamayı makinenize yükleyin. Yüklemeyi tamamladıktan sonra Antigravity uygulamasını başlatın.

Kurulum sırasında uygulanan temel adımlar:

• Kurulum akışını seçin: Bu codelab için yeni bir başlangıç yapmanızı öneririz.
• İncelemeye dayalı geliştirme (önerilir): Bu seçeneği belirleyin. Bu sayede aracı karar verebilir ve onay için kullanıcıya geri dönebilir. Bu, altyapı işlemleri için kritik öneme sahiptir.

Ardından, Editor'ınızı yapılandırın ve Google'da oturum açın. Son olarak, Kullanım Şartları'nı kabul edin.

4. Altyapı Kurulumu: GKE ve Config Connector

Beceri oluşturabilmek için Config Connector (KCC)'ın manuel olarak yüklendiği ve Namespaced Mode'da yapılandırıldığı bir Google Cloud ortamına ihtiyacınız vardır. Bu sayede GCP kaynaklarını Kubernetes nesneleri olarak yönetebilirsiniz.

0. adım: Ortamınızı hazırlayın

1. Küme Ön Koşulları

Gerekli özelliklerin etkin olduğu yeni bir GKE kümesi oluşturun:

# Set your variables
export PROJECT_ID=$(gcloud config get-value project)
export CLUSTER_NAME="kcc-ops-cluster"
export REGION="us-central1"

# Create the cluster
gcloud container clusters create ${CLUSTER_NAME} \
    --region ${REGION} \
    --release-channel "regular" \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --logging=SYSTEM \
    --monitoring=SYSTEM

# Get cluster credentials
gcloud container clusters get-credentials ${CLUSTER_NAME} --region ${REGION}

2. Config Connector operatörünü yükleme

Operatör, kurulumunuzu güncel tutar.

# Download the latest Config Connector operator
gcloud storage cp gs://configconnector-operator/latest/release-bundle.tar.gz release-bundle.tar.gz

# Extract the bundle
tar zxvf release-bundle.tar.gz

# Install the operator (Standard Cluster)
kubectl apply -f operator-system/configconnector-operator.yaml

3. Ad alanlı modu yapılandırma

Çalışma modunu belirtmek için ConfigConnector kaynağı oluşturun.

# configconnector.yaml
apiVersion: core.cnrm.cloud.google.com/v1beta1
kind: ConfigConnector
metadata:
  name: configconnector.core.cnrm.cloud.google.com
spec:
  mode: namespaced
  stateIntoSpec: Absent

kubectl apply -f configconnector.yaml

4. Kimlik ve ad alanı oluşturma

Bu laboratuvarda default ad alanını ve özel bir Google hizmet hesabı (GSA) kullanacağız.

# Set your variables
export PROJECT_ID=$(gcloud config get-value project)
export NAMESPACE="default"

# Create the Google Service Account
gcloud iam service-accounts create kcc-identity --project ${PROJECT_ID}

# Grant permissions on the project
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:kcc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/owner"

# Grant Metric Writer permissions
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:kcc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter"

# Bind GSA to KSA via Workload Identity
gcloud iam service-accounts add-iam-policy-binding \
    kcc-identity@${PROJECT_ID}.iam.gserviceaccount.com \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[cnrm-system/cnrm-controller-manager-${NAMESPACE}]" \
    --role="roles/iam.workloadIdentityUser"

5. Ad alanını yapılandırma

Ad alanını izlemek için bir ConfigConnectorContext oluşturun.

# configconnectorcontext.yaml
apiVersion: core.cnrm.cloud.google.com/v1beta1
kind: ConfigConnectorContext
metadata:
  name: configconnectorcontext.core.cnrm.cloud.google.com
  namespace: default
spec:
  googleServiceAccount: "kcc-identity@${PROJECT_ID}.iam.gserviceaccount.com"
  stateIntoSpec: Absent

kubectl apply -f configconnectorcontext.yaml

6. Yüklemeyi Doğrulama

Denetleyicinin default ad alanı için hazır olmasını bekleyin.

kubectl wait -n cnrm-system \
    --for=condition=Ready pod \
    -l cnrm.cloud.google.com/component=cnrm-controller-manager \
    -l cnrm.cloud.google.com/scoped-namespace=default

5. Agent Manager: Mission Control

Antigravity, açık kaynaklı Visual Studio Code (VS Code) temelini kullanır ancak kullanıcı deneyimini kökten değiştirerek metin düzenleme yerine aracı yönetimine öncelik verir. Arayüz, iki ayrı birincil pencereye ayrılmıştır: Editor ve Agent Manager.

Temsilci Yöneticisi

Kullanıcı, Antigravity'yi başlattığında genellikle Ajan Yöneticisi tarafından karşılanır. Bu arayüz, Görev Kontrolü kontrol paneli işlevi görür. Üst düzey düzenleme için tasarlanmıştır. Geliştiricilerin farklı çalışma alanlarında veya görevlerde eşzamansız olarak çalışan birden fazla aracı oluşturmasına, bunları izlemesine ve bunlarla etkileşime girmesine olanak tanır.

Bu görünümde geliştirici, mimar rolündedir. Üst düzey hedefleri tanımlarlar. Bu isteklerin her biri, özel bir aracı örneği oluşturur. Kullanıcı arayüzü, bu paralel iş akışlarının görselleştirilmesini sağlar. Her aracının durumunu, ürettiği Artifacts'i (planlar, sonuçlar, farklılıklar) ve insan onayı bekleyen tüm istekleri gösterir.

6. Antigravity Browser & Artifacts

Antigravity, planlama yaparken ve işlerini tamamlarken Yadigarlar oluşturur. Bunlar zengin markdown dosyaları, mimari diyagramlar, resimler, tarayıcı kayıtları ve kod farklılıklarıdır.

Artifacts, "güven boşluğunu" kapatır

Bir temsilci "Hatayı düzelttim" dediğinde geliştiricinin daha önce kodu okuyarak doğrulaması gerekiyordu. Antigravity'de, ajan bunu kanıtlamak için bir eser üretiyor.

Yapılar

Antigravity tarafından üretilen başlıca yapılar şunlardır:

• Task Lists: Kod yazmadan önce oluşturulan yapılandırılmış bir plan.
• Implementation Plan: Teknik ayrıntılarla birlikte değişiklikler tasarlayın.
• Walkthrough: Değişikliklerin özeti ve nasıl test edileceği.
• Browser Recordings: Kullanıcı arayüzü doğrulama için tarayıcı oturumlarının video kayıtları.

Antigravity Browser

Temsilcinin web ile etkileşime girmesi gerektiğinde tarayıcı alt temsilcisi çağrılır. Bu alt aracı; tıklama, kaydırma, yazma ve konsol günlüklerini okuma işlemlerini yapabilir. Antigravity tarafından yönetilen tarayıcıda açık olan sayfalarda çalışmak için özel bir model kullanır.

7. Düzenleyici deneyimi

Düzenleyici, VS Code'un alışılmış özelliklerini korur. Standart dosya gezgini, söz dizimi vurgulama ve uzantı ekosistemi içerir.

Key Editor'ın temel özellikleri:

• Otomatik tamamlama: Sekme tuşuna basılarak kabul edilen akıllı öneriler.
• İçe aktarılacak sekme: Eksik bağımlılıkların eklenmesini önerir.
• Komutlar (Cmd + I): Doğal dili kullanarak satır içi tamamlama özelliğini tetikleyin.
• Aracı Yan Paneli (Cmd + L): @ kullanarak soru sormak veya dosyalara başvurmak için aracı panelini açıp kapatın.

8. Geri bildirimde bulunma

Antigravity'nin temelinde, geri bildirimlerinizi kolayca toplama özelliği yer alır. Bu yapılar, Google Dokümanlar tarzı yorumlarla aracıya geri bildirimde bulunmanızı sağlar.

Bir plana veya göreve yorum eklediğinizde yorumu göndermeyi unutmayın. Bu, temsilciyi istediğiniz yöne yönlendirir.

9. KCC Ops becerisini oluşturma

Platformu anladığınıza göre şimdi KCC Ops Skill'i oluşturalım.

Kubernetes Config Connector (KCC), GCP kaynaklarını K8s nesneleri olarak yönetmenize olanak tanır. Ancak yapılandırma kaymasını, uygunluk ihlallerini ve yanlışlıkla kaynak yeniden oluşturmayı önlemek için güvenlik önlemleri gerektirir.

1. adım: Beceriye yapı kazandırın

Çalışma alanınızın kök dizininde beceriniz için dizin yapısını oluşturun:

mkdir -p .agents/skills/kcc-ops/scripts
mkdir -p .agents/skills/kcc-ops/resources/policies/templates
mkdir -p .agents/skills/kcc-ops/resources/policies/constraints

2. adım: SKILL.md dosyasını oluşturun (Beyin)

SKILL.md, meta verileri ve aracının temel "Altın Kural"ını tanımlar. Oluşturma .agents/skills/kcc-ops/SKILL.md:

---
name: kcc-ops
description: Assists with Config Connector (KCC) configuration, resource generation, and troubleshooting on Google Cloud.
---

# Config Connector (KCC) Operations Skill

Use this skill to manage Google Cloud resources using Kubernetes-style configuration (Config Connector).

## 🛑 GOLDEN RULE: Separate Generation from Application

**NEVER generate and apply a manifest in a single autonomous step.**

1. **Craft:** Write the generated manifest to a local file.
2. **Analyze:** Present the manifest to the user. Perform Impact Analysis and Dry Runs. Explain the consequences of the change (e.g., "If this topic is deleted, the attached subscription becomes orphaned").
3. **Wait:** Pause execution and explicitly wait for user permission to proceed.
4. **Apply:** Only run `kubectl apply` *after* the user has reviewed the manifest and the impact analysis, and then unequivocally confirmed you should proceed.

## Core Responsibilities

0. **Context Verification**: Verify the execution context (cluster, namespace, GCP project, user account) with the user before performing any operations.
1. **Installation & Health**: Verify KCC is properly installed and healthy on the target cluster.
2. **Resource Inventory**: Query and summarize existing KCC resources within a namespace.
3. **Brownfield Bulk Export (Adoption)**: Export existing GCP project resources into valid KCC YAML manifests.
4. **Manifest Generation**: Generate valid YAML manifests for GCP resources using KCC CRDs.
5. **Impact Analysis**: Identify ancillary services and resources (e.g., Cloud Run, Apps) that depend on a resource being modified.
6. **Change Differentiation**: Generate diff summaries for resource edits to support change control.
7. **Policy Compliance**: Vet KCC manifests against OPA/Gatekeeper policies.
8. **Troubleshooting**: Analyze resource status, and consult the troubleshooting guide to resolve reconciliation issues.

## Guidelines for Operations

### 0. Context Verification

Before performing **any operations or executing commands** (including health checks), you **MUST** verify the current execution context and obtain explicit user confirmation.

1. **Read Context:** Use commands like `kubectl config current-context`, `kubectl config view --minify -o jsonpath='{.contexts[0].context.namespace}'`, `gcloud config get-value project`, and `gcloud config get-value account` to determine the active environment.
2. **Present & Ask:** Show this information to the user clearly (e.g., "I see my context is X, namespace is Y, project is Z, and account is A. Is this correct?").
3. **Wait:** Do not proceed with any other steps or scripts until the user has confirmed or provided corrections.

### 1. Installation & Health Check

Before performing operations, ensure the environment is ready:

- **Automation**: You MUST use `./scripts/check-health.sh` to verify namespaces, controllers, and CRDs. Do not use manual kubectl commands for health checks, as the script enforces standard formatting and context verification.

### 2. Resource Inventory & Discovery

To understand the current state of infrastructure:

- **Automation**: You MUST use `./scripts/inventory.sh` to get a summary table of all KCC resources. Do not use manual kubectl queries, as the script is optimized to securely discover all CRDs with context validation.

### 3. Manifest Structure

- All KCC resources belong to the `cnrm.cloud.google.com` API group.
- Use the `cnrm.cloud.google.com/project-id` annotation for cross-project resource management if not using Namespaced Mode.
- Always include `apiVersion`, `kind`, `metadata`, and `spec`.

### 4. Official Resource Reference (Agent Action)

When generating or troubleshooting manifests, you **must not guess** the API schema. Always consult the [Official Config Connector Reference](https://cloud.google.com/config-connector/docs/reference/overview) for the exact API version, kind, and required fields for the specific resource and cross reference with the official [github repository](https://github.com/GoogleCloudPlatform/k8s-config-connector/tree/master/config/crds/resources).

### 5. Troubleshooting Checklist

When a resource is not reconciling (check `kubectl get <kind> <name> -o yaml`):

- **Ready Condition**: Look for `status.conditions` where `type: Ready` and `status: "False"`.
- **Reason/Message**: Check the `reason` and `message` fields in the status conditions.
- **Consult the Guide**: Immediately check `./resources/troubleshooting-guide.md` for definitions of the error reason (e.g. `DependencyInvalid`, `ManagementConflict`) and follow its resolution steps.
- **Common Issues**:
  - Permissions: The KCC service account lacks IAM roles.
  - Quotas: GCP project quota exceeded.
  - Conflicts: Resource already exists or is managed by another tool.
  - Immutable Fields: Attempting to change a field that requires resource recreation. Look for "Update failed" errors related to immutable fields.
  - Reference Resolution: Check if the resource is waiting for a dependency (e.g., `referenced project not found`).

### 6. Impact Analysis (Ancillary Services)

Before modifying a resource (e.g., GCS Bucket, Pub/Sub Topic), verify whatElse depends on it:

- **Reference Search (Cluster-wide)**: Search for other KCC resources that reference the item.

  ```bash
  # Example: Find resources referencing a bucket named 'my-data-bucket'
  kubectl get-all -n <namespace> -o yaml | grep -C 5 "my-data-bucket"
  ```

- **IAM-based Analysis**: Check for IAM Service Accounts that have roles on the specific resource. A Cloud Run job or GKE Workload Identity might be using those permissions.
- **Common Ancillary Dependencies**:
  - **Storage Buckets**: Look for Cloud Run/GKE mounts (CSI), Cloud Functions triggers, or Dataflow jobs.
  - **Networks**: Check for Firewall rules, Forwarding rules, and GKE cluster assignments.
  - **IAM Policies**: Changing a policy might break access for external applications not managed by KCC.
- **Resource Graph**: Use `gcloud asset search-all-resources` to find resources that might have implicit links.

### 3. Policy Compliance & Best Practices

Evaluate KCC manifests against security and governance policies. The vetting tool supports three source modes:

- **Built-in Mode (Default)**: Uses the skill's high-fidelity `v1beta1` library (300+ Anthos constraints).
  - `Usage: ./scripts/vet-policy.sh <manifest-path>`
- **Remote Mode**: Clones and vets against an external Git repository.
  - `Usage: ./scripts/vet-policy.sh <manifest-path> <repo-url> [git-ref]`
  - ⚠️ **Note**: External libraries like the legacy GCP Policy Library may be out-of-date and cause schema validation errors with modern `gator`.
- **Local Mode**: Vets against a local directory of policies.
  - `Usage: ./scripts/vet-policy.sh <manifest-path> /path/to/local/policies`

**Interaction Model:**

1. Call `./scripts/vet-policy.sh` with the appropriate arguments.
2. Interpret the `=== KCC Best Practices ===` and `=== OPA/Gatekeeper ===` reports.
3. Supplement automated findings with manual review for specific security features not yet covered by OPA (e.g., `publicAccessPrevention: enforced`, `versioning: {enabled: true}`).

  ```bash
  # Run the skill's helper script (repo URL and branch are optional)
  ./scripts/vet-policy.sh manifest.yaml [policy-repo-url] [policy-ref]
  ```

## Skill Assets

This skill includes additional resources to streamline operations:

- **`scripts/`**: Automation scripts (e.g., `vet-policy.sh`, `bulk-export.sh`).
- **`examples/`**: Reference KCC manifests (e.g., `restricted-bucket.yaml`).
- **`resources/`**: Common templates, documentation snippets, and troubleshooting guides (e.g., `troubleshooting-guide.md`).

### 4. Safety Rails for Applying Manifests

Before applying any KCC manifest update to an existing resource, you MUST:

- **Verify Immutable Fields**: Call `./scripts/verify-immutable.sh <manifest-path>` to detect updates to fields (like `location`, `name`, `project-id`) that trigger destructive resource recreation.
- **Explain Impact**: If destructive changes are detected, you MUST warn the user and explain the downtime/data loss implications before requesting approval.

### 5. Emergency Recovery & Troubleshooting

If a resource is stuck in a "Deletion" or "Error" state:

- **Check for Abondon Flag**: Check if the resource has the `cnrm.cloud.google.com/deletion-policy: abandon` annotation. If it does, you will need to remove the annotation and then force delete the resource.
- **Force Delete**: Call `./scripts/force-delete.sh <kind> <name> [namespace]` to bypass Kubernetes finalizers and remove the resource from the cluster.
- **Orphan Warning**: Inform the user that force-deleting a KCC object may leave an orphaned resource in Google Cloud that requires manual cleanup.

### 6. Change Differentiation

When editing an existing resource, always generate a diff to summarize the change for reviewers or Git history:

- **Local Diff**:

  ```bash
  # Diff a local file against the cluster state
  kubectl diff -f modified-resource.yaml
  ```

- **Commit Summary Template**:

  ```text
  [KCC Change] Update <ResourceName> (<Kind>)
  - Field 'spec.foo' changed from 'X' to 'Y'
  - Impact: Ancillary service <ServiceName> will see updated <Config>
  ```

### 9. Best Practices

- **Namespaced Mode**: Prefer namespaced mode for better isolation.
- **Sensitive Data**: Use `spec.credential.secretRef` or similar for sensitive fields.
- **Resource Naming**: Use consistent naming conventions that match your Kubernetes/GCP standards.
- **Annotations**:
  - `cnrm.cloud.google.com/deletion-policy: abandon`: Keep GCP resource on KCC deletion.
  - `cnrm.cloud.google.com/state-into-spec: absent`: Prevents KCC from syncing GCP state back into the Kubernetes object (useful for avoiding reconciliation loops on fields like node counts).

## Common Resource Examples

### Compute Instance

```yaml
apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeInstance
metadata:
  name: instance-sample
  annotations:
    cnrm.cloud.google.com/project-id: "my-project-id"
spec:
  machineType: n1-standard-1
  zone: us-central1-a
  bootDisk:
    initializeParams:
      sourceImage: projects/debian-cloud/global/images/family/debian-11
  networkInterface:
    - networkRef:
        name: default
```

### Storage Bucket

```yaml
apiVersion: storage.cnrm.cloud.google.com/v1beta1
kind: StorageBucket
metadata:
  name: bucket-sample
spec:
  location: US
```

### Pub/Sub Topic & Subscription

```yaml
apiVersion: pubsub.cnrm.cloud.google.com/v1beta1
kind: PubSubTopic
metadata:
  name: order-events-topic
---
apiVersion: pubsub.cnrm.cloud.google.com/v1beta1
kind: PubSubSubscription
metadata:
  name: order-processor-sub
spec:
  topicRef:
    name: order-events-topic
  ackDeadlineSeconds: 30
```

3. adım: Envanter aracını uygulayın

KCC kaynaklarını keşfetmek için .agents/skills/kcc-ops/scripts/inventory.sh oluşturun:

#!/bin/bash
# List all resources in the cnrm.cloud.google.com group
KCC_KINDS=$(kubectl api-resources --no-headers | awk '/\.cnrm\.cloud\.google\.com/ {print $1}')
KCC_KINDS_CSV=$(echo "$KCC_KINDS" | paste -sd, -)

printf "%-40s %-30s %-10s %s\n" "KIND" "NAME" "READY" "STATUS/MESSAGE"
kubectl get "$KCC_KINDS_CSV" -A -o custom-columns="KIND:.kind,NAME:.metadata.name,READY:.status.conditions[?(@.type=='Ready')].status,MSG:.status.conditions[?(@.type=='Ready')].message" --ignore-not-found --no-headers

4. adım: Politika inceleme mantığını ekleyin

Oluşturma .agents/skills/kcc-ops/scripts/vet-policy.sh Bu komut dosyası, manifestleri OPA politikalarına göre incelemek için gator kullanır:

#!/bin/bash
MANIFEST=$1
SKILL_ROOT=$(dirname "$(dirname "$0")")
POLICY_SRC="$SKILL_ROOT/resources/policies"

echo "=== OPA/Gatekeeper Policy Vetting ==="
if command -v gator >/dev/null 2>&1; then
    gator test -f "$MANIFEST" -f "$POLICY_SRC/templates" -f "$POLICY_SRC/constraints"
else
    echo "Gator not found. Skipping OPA audit."
fi

5. adım: Değişmez alan korumasını uygulayın

Bu, kritik bir güvenlik önlemidir. Oluşturma .agents/skills/kcc-ops/scripts/verify-immutable.sh:

#!/bin/bash
MANIFEST=$1
KIND=$(grep "^kind:" "$MANIFEST" | awk '{print $2}')
NAME=$(grep "name:" "$MANIFEST" | head -n 1 | awk '{print $2}')

# Check for changes in common immutable fields
IMMUTABLE_FIELDS=("location" "project-id" "name" "zone" "region")
TEMP_FILE=$(mktemp)
kubectl get "$KIND" "$NAME" -o yaml > "$TEMP_FILE" 2>/dev/null

for field in "${IMMUTABLE_FIELDS[@]}"; do
    NEW=$(grep "$field:" "$MANIFEST" | awk '{print $2}')
    OLD=$(grep "$field:" "$TEMP_FILE" | awk '{print $2}')
    if [ -n "$NEW" ] && [ -n "$OLD" ] && [ "$NEW" != "$OLD" ]; then
        echo "🚨 WARNING: Immutable field '$field' is changing! Potential resource recreation."
    fi
done
rm "$TEMP_FILE"

6. adım: Acil kurtarma (zorunlu silme)

Oluşturma .agents/skills/kcc-ops/scripts/force-delete.sh:

#!/bin/bash
KIND=$1; NAME=$2; NS=${3:-default}
echo "Removing finalizers for $KIND/$NAME in $NS..."
kubectl patch "$KIND" "$NAME" -n "$NS" -p '{"metadata":{"finalizers":null}}' --type=merge
kubectl delete "$KIND" "$NAME" -n "$NS" --wait=false

7. adım: Kaynakları sonlandırın

Tüm komut dosyalarını yürütülebilir hale getirin:

chmod +x .agents/skills/kcc-ops/scripts/*.sh

10. Yeni becerinizi test etme

Şimdi yeni bir görüşme başlatın ve becerinizi test edin:

1. Keşif: @kcc-ops Show me all KCC resources in my cluster.
2. Uygunluk: StorageBucket ile bucket.yaml dosyası oluşturun. Şunu sor: @kcc-ops Vet my bucket.yaml manifest.
3. Güvenlik: bucket.yaml içindeki mevcut bir paketin location değerini güncellemeye çalışın. Şunu sor: @kcc-ops Verify my bucket.yaml for immutable changes.

Temsilcinin doğru senaryoyu akıllıca seçtiğini ve SKILL.md bölümündeki "Altın Kural"a uyduğunu fark edin.

11. Aracıyı Güvenli Hale Getirme

Yapay zeka aracısına terminalinize erişim izni vermek güçlü bir özellik olsa da kontrol gerektirir.

Antigravity - Ayarlar - Terminal'e gidip İzin Listesi ve Reddetme Listesi'ni inceleyin.

• İzin verilenler listesi: ls, kubectl get ve beceri komut dosyalarınızı buraya ekleyin.
• Reddetme Listesi: Ajanın HER ZAMAN izin istemesini sağlamak için sudo, rm -rf veya diğer yıkıcı komutları ekleyin.

12. Sonuç

Tebrikler! Antigravity'yi yüklemekten yüksek doğrulukta bir KCC Operations Skill oluşturmaya geçtiniz.

Öğrendikleriniz:

• Özel bash araçlarıyla ajanın kapsamını genişletme
• Operasyonel "Altın Kurallar"ı SKILL.md olarak kodlama
• Karmaşık altyapı yönetimi için güvenlik önlemleri alma

Sırada ne var?

resources/policies klasörünüzü daha fazla OPA kısıtlamasıyla genişletin veya küme hazırlık kontrollerini otomatikleştirmek için check-health.sh komut dosyası ekleyin.