Belajar A2A - Policy-as-Code & Automation

#Pendahuluan

Episode 19 memperlihatkan sisi komersial ekosistem A2A: agent bisa meminta bayaran lewat x402, dikendalikan mandate dan approval, lalu diselesaikan lewat trust rails. Tapi di balik layar, semua kemampuan itu hanya berguna jika service-nya bisa dikelola dengan disiplin. Episode 20 membawa A2A ke ranah operasional: automation dan policy-as-code. Kita akan membangun pipeline CI/CD yang men-deploy agent service ke Docker dan Cloud Run, menulis pengujian multi-agent yang benar-benar mengeksekusi task di pipeline, menerapkan contract testing terhadap agent card, lalu menata governance — versioning agent, deprecation policy, dan SLA per agent yang bisa diukur.

#Deploy Agent Service dengan CI/CD

Agent service tidak berbeda dari service web biasa: ia butuh image, pipeline, dan target deployment. Docker adalah titik awal yang paling netral — image yang sama bisa berjalan di lokal, staging, maupun produksi.

FROM node:22-slim AS build
WORKDIR /app
COPY package.json bun.lock ./
RUN bun install --frozen-lockfile
COPY . .
 
FROM node:22-slim AS runtime
WORKDIR /app
ENV NODE_ENV=production
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY --from=build /app/agent-card.json ./agent-card.json
EXPOSE 3000
CMD ["node", "dist/server.js"]

Agent card ikut di-copy ke dalam image karena ia artefak rilis, bukan file konfigurasi. Ketika kartu berubah, versi image ikut berubah — dan client yang me-cache kartu mendapat sinyal lewat metadata versi. Untuk platform serverless seperti Cloud Run, deployment dilakukan setelah build dan test hijau, cukup satu baris di pipeline:

deploy:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - name: Build image
      run: docker build -t a2a-agent:${{ github.sha }} .
    - name: Deploy to Cloud Run
      run: |
        gcloud run deploy a2a-agent --image gcr.io/my-project/a2a-agent:${{ github.sha }} \
          --region asia-southeast1 --allow-unauthenticated

Pola tag memakai commit SHA menjamin setiap deploy bisa dilacak balik ke commit persisnya. Untuk verifikasi cepat di lokal sebelum didorong ke pipeline, jalankan docker build -t a2a-agent:dev .. Prinsip ini sama untuk Cloud Run, ECS, atau Kubernetes — yang berubah hanya targetnya.

#Test Multi-Agent di Pipeline

Pipeline yang hanya build tanpa menjalankan agent adalah false confidence. Test yang berharga untuk A2A harus menjalankan dua agent sungguhan dan mengirim task nyata di antara mereka — bukan mocking.

test-multi-agent.py

import pytest
 
@pytest.mark.asyncio
async def test_agent_ke_agent():
    async with run_server(agent_analisa) as url_a, run_server(agent_ringkas) as url_b:
        client = A2AClient(httpx.AsyncClient())
 
        task = await client.send_task(url_a, {
            "parts": [{"type": "text", "text": "Ringkas laporan ini"}],
        })
        assert task.status == "completed"
 
        hasil = task.artifact.parts[0].text
        assert len(hasil) > 0
 
        task_b = await client.send_task(url_b, {
            "parts": [{"type": "text", "text": f"Terjemahkan: {hasil}"}],
        })
        assert task_b.status == "completed"

Beberapa hal yang wajib diuji selain alur bahagia:

• State machine: setiap task berpindah dari submitted ke working, lalu ke terminal state — tidak ada yang menggantung di working.
• Error path: kirim payload tidak valid, pastikan agent membalas failed dengan pesan yang bisa dibaca client.
• Streaming: jika agent mendukung SSE, pastikan event stream tertutup dengan benar saat task selesai.
• Auth: jalankan sekali dengan kredensial valid dan sekali tanpa kredensial — keduanya harus berperilaku sesuai kebijakan.

Test ini berjalan di setiap pull request, sehingga regresi antar agent terdeteksi sebelum produksi — pembeda antara kumpulan kode dan sistem yang benar-benar berkolaborasi.

#Contract Testing: Agent Card sebagai Kontrak

Ketika banyak client mengandalkan agent card kalian, perubahan kecil pada kartu bisa merusak semua klien. Contract testing memperlakukan agent card sebagai kontrak publik yang diuji secara eksplisit.

test-contract-card.py

import jsonschema
import pytest
 
SCHEMA = load_json("agent-card-schema.json")
 
def test_agent_card_valid():
    card = load_json("agent-card.json")
    jsonschema.validate(card, SCHEMA)
 
def test_skill_id_stabil():
    card = load_json("agent-card.json")
    for skill in card["skills"]:
        assert skill["id"].startswith("a2a-agent:")
 
def test_breaking_change_terdeteksi():
    lama = load_json("agent-card.v1.json")
    baru = load_json("agent-card.json")
    for skill in lama["skills"]:
        if skill["id"] not in [s["id"] for s in baru["skills"]]:
            pytest.fail("skill yang dideprekasi belum lewat masa transisi")

Validasi schema menangkap kartu yang rusak; asersi id menangkap skill yang hilang diam-diam. Yang terpenting adalah test ketiga: perubahan breaking harus disengaja dan dijadwalkan, bukan hasil refactor yang kebetulan menghapus sebuah skill.

#Versioning Agent dan Deprecation Policy

Versioning adalah bahasa yang disepakati antara pemilik agent dan client-nya. Untuk A2A ada dua hal yang diver: versi protokol (ditangani version negotiation, dibahas di episode 10 dan 21) dan versi kemampuan agent — versi agent card.

Praktik yang sehat:

• Semantic versioning pada agent card: major naik ketika ada skill dihapus atau parameter berubah breaking; minor ketika ada skill baru yang additif; patch untuk deskripsi dan metadata.
• Field deprecation: tandai skill yang menuju pensiun dengan flag deprecated dan tanggal sunset, bukan langsung menghapus.
• Masa transisi: minimal dua major version didukung bersamaan — misalnya v2 aktif sementara v1 menerima task dan membalas dengan header sunset.

{
  "agentName": "a2a-agent",
  "cardVersion": "3.2.0",
  "protocolVersion": "1.0",
  "skills": [
    {
      "id": "a2a-agent:analisa-kredit",
      "name": "Analisa Kredit",
      "deprecated": true,
      "sunset": "2026-12-31"
    },
    {
      "id": "a2a-agent:analisa-kredit-v2",
      "name": "Analisa Kredit v2",
      "inputs": ["skor_kredit", "riwayat"]
    }
  ]
}

Client yang cerdas membaca tanda deprecated dan sunset, lalu bermigrasi sebelum tenggat. Deprecation policy yang tertulis adalah perjanjian — bukan perintah yang tiba-tiba.

#SLA per Agent

Terakhir, agent harus punya SLA yang terukur. Tanpa angka, client tidak bisa mempercayai agent untuk task kritis. Empat metrik yang umum:

• Availability: persentase waktu agent bisa menerima task — target umum 99.5 persen ke atas.
• Latency task: p50, p95, dan p99 dari durasi task — bukan hanya rata-rata yang bisa menipu.
• Error rate: proporsi task yang berakhir di status failed — menandakan masalah kualitas, bukan hanya masalah uptime.
• Throughput: kapasitas task per detik sebelum load shedding mulai berlaku.

agent: a2a-agent
version: "3.2.0"
slo:
  availability: "99.5%"
  latency_p95: "4s"
  error_rate: "0.5%"
  throughput_per_sec: 500
windows:
  - "1m"
  - "7d"

Menerbitkan SLO di samping agent card memungkinkan client membaca kapasitas yang dijanjikan sebelum mengirim task. Karena SLO ini versi-sensitif, perbaikan performa di major release terlihat sebagai peningkatan angka.

#Penutup

Episode 20 menutup kesenjangan antara "agent berfungsi di laptop" dan "agent berjalan di produksi". CI/CD memastikan deploy berulang dan bisa dilacak, test multi-agent membuktikan kolaborasi nyata di pipeline, contract testing melindungi agent card sebagai kontrak publik, dan governance — versioning, deprecation, dan SLA — memberikan bahasa yang disepakati antara pemilik dan konsumen agent.

Inti yang harus dibawa pulang:

• Agent card adalah artefak rilis: ikut image, diver, dan diuji sebagai kontrak.
• Test multi-agent harus mengeksekusi task sungguhan antar agent, bukan mocking.
• Contract testing mendeteksi perubahan breaking sebelum partner terpengaruh.
• Versioning plus deprecation policy membuat migrasi terencana, bukan kejutan.
• SLA yang terukur memberi client alasan untuk mempercayai agent kalian.

Di episode 21 kita menengok ke cakrawala: fitur modern dan roadmap A2A — mulai dari v1.0 yang stabil dengan signed agent cards, multi-tenancy, dan version negotiation, hingga arah pengembangan discovery dan keamanan. Sampai jumpa!