Container Service for Kubernetes:Deploy an Agent2Agent (A2A) protocol server in Knative

Cómo funciona

Los agentes de IA cuentan con capacidades de inference, planificación y memoria. Esto les permite aprender de forma autónoma y completar tareas en nombre de los usuarios. De manera similar a como Model Context Protocol (MCP) proporciona un estándar de acceso a datos para los modelos de lenguaje extensos (LLM), el protocolo Agent2Agent (A2A) ofrece una definición estandarizada para la interoperabilidad entre agentes.

El despliegue de un servidor A2A en Knative implica las siguientes interacciones principales:

• Descubrimiento: Una vez desplegado el Service, este expone una interfaz mediante una Agent Card estándar. Así, otros agentes pueden consultar sus habilidades (AgentSkill) y capacidades (AgentCapabilities).

• Comunicación: Las capacidades de gateway y enrutamiento de Service (Ingress) de Knative gestionan los intercambios de mensajes estándar sobre HTTP/gRPC.

• Colaboración: Los agentes delegan tareas y coordinan acciones mediante API.

Consulte la especificación de A2A para conocer la arquitectura del protocolo de comunicación entre agentes y los conceptos clave .

Preparativos

• El complemento de Knative está desplegado en el clúster. Para obtener más información, consulte Deploy and manage Knative components.

• Obtuvo la dirección del gateway de acceso.

  Esta dirección se obtiene en la página Add-ons o Services de Knative. A continuación se muestra un ejemplo de cómo obtenerla.

  En la parte inferior de la página Service Management, consulte la dirección de Access Gateway. Su formato es similar a alb-<instance ID>.cn-hangzhou.alb.aliyuncsslb.com.

Paso 1: Desplegar el servidor A2A

Este ejemplo despliega un Service básico de agente llamado helloworld-agent-server.

1. Cree el archivo a2a-service.yaml.

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: helloworld-agent-server
     # Update the namespace as needed
     namespace: default 
     annotations:
       # Use a wildcard domain name for quick verification
       knative.aliyun.com/serving-ingress: / 
   spec:
     template:
       spec:
         containers:
         # Replace {region} with the actual region, such as cn-hangzhou
         - image: registry-{region}-vpc.ack.aliyuncs.com/acs/knative-samples-a2a:v1.0-952c112
           name: user-container
           env:
           # INVOKE defines the invoke URL returned in the Agent Card. Replace it with the service access gateway address.
           - name: INVOKE
             value: http://<YOUR_GATEWAY_ADDRESS>/invoke
           ports:
           - containerPort: 9001
             name: http1
             protocol: TCP

2. Despliegue el Service.

   kubectl apply -f a2a-service.yaml

3. Compruebe el estado del Service de Knative.

   kubectl get ksvc helloworld-agent-server

   Resultado esperado:

   NAME                      URL                                                  LATESTCREATED                   LATESTREADY                     READY   REASON
   helloworld-agent-server   http://helloworld-agent-server.default.example.com   helloworld-agent-server-00001   helloworld-agent-server-00001   True    

Paso 2: Comprobar el Service y recuperar la Agent Card

Una vez completado el despliegue, compruebe que el Service devuelva correctamente una Agent Card compatible con el protocolo A2A.

1. Obtenga la dirección del gateway de acceso y el nombre de dominio predeterminado del Service.

   1. En la página Clústeres de ACK, haga clic en el nombre de su clúster. En el panel de navegación izquierdo, haga clic en Applications > Knative.

   2. En la página Services, obtenga el Default Domain del Service.

      A continuación se muestran el Gateway y el Default Domain.

      La dirección del gateway de acceso sigue el formato alb-<instance ID>.cn-hangzhou.alb.aliyuncsslb.com. El Service helloworld-agent-server se encuentra en estado correcto y su nombre de dominio predeterminado es helloworld-agent-server.default.example.com.

2. Acceda al endpoint de metadatos del Service.

   # Replace <GATEWAY_ADDRESS> with the access gateway address that you obtained
   curl http://<GATEWAY_ADDRESS>/.well-known/agent-card.json | jq .

   Revise el resultado esperado. Este debe incluir las capacidades del agente (capabilities), la descripción (description) y la lista de habilidades (skills).

   {
     "capabilities": {
       "streaming": true
     },
     "defaultInputModes": [
       "text"
     ],
     "defaultOutputModes": [
       "text"
     ],
     "description": "Just a hello world agent",
     "name": "Hello World Agent",
     "preferredTransport": "JSONRPC",
     "protocolVersion": "",
     "skills": [
       {
         "description": "Returns a 'Hello, world!'",
         "examples": [
           "hi",
           "hello"
         ],
         "id": "hello_world",
         "name": "Hello, world!",
         "tags": [
           "hello world"
         ]
       }
     ],
     "url": "http://XXX/invoke",
     "version": ""
   }

Paso 3: Llamar al Service con un cliente A2A

Escriba código de cliente en Go para simular otro agente que se comunica con el servidor A2A desplegado.

1. Prepare el entorno de desarrollo e instale Go.

2. Cree el archivo main.go y agregue el siguiente código.

   package main
   import (
   	"context"
   	"flag"
   	"log"
   	// Import the core libraries for the A2A protocol
   	"github.com/a2aproject/a2a-go/a2a"
   	"github.com/a2aproject/a2a-go/a2aclient"
   	"github.com/a2aproject/a2a-go/a2aclient/agentcard"
   	// Import gRPC-related libraries
   	"google.golang.org/grpc"
   	"google.golang.org/grpc/credentials/insecure"
   )
   // Replace <GATEWAY_ADDRESS> with the access gateway address that you obtained
   var cardURL = flag.String("card-url", "http://<GATEWAY_ADDRESS>", "Base URL of AgentCard client.")
   func main() {
   	flag.Parse()
   	ctx := context.Background()
   	// Service discovery
   	card, err := agentcard.DefaultResolver.Resolve(ctx, *cardURL)
   	if err != nil {
   		log.Fatalf("Failed to resolve an AgentCard: %v", err)
   	}
   	// Configure the transport layer
   	withInsecureGRPC := a2aclient.WithGRPCTransport(grpc.WithTransportCredentials(insecure.NewCredentials()))
   	// Create the client
   	client, err := a2aclient.NewFromCard(ctx, card, withInsecureGRPC)
   	if err != nil {
   		log.Fatalf("Failed to create a client: %v", err)
   	}
   	// Build the message
   	msg := a2a.NewMessage(a2a.MessageRoleUser, a2a.TextPart{Text: "Hello, world"})
   	resp, err := client.SendMessage(ctx, &a2a.MessageSendParams{Message: msg})
   	if err != nil {
   		log.Fatalf("Failed to send a message: %v", err)
   	}
   	log.Printf("Server responded with: %+v", resp)
   }

3. Ejecute el código para probarlo.

   go mod init a2a-demo
   go mod tidy
   go run main.go

   El siguiente resultado esperado indica que el cliente se conectó correctamente al Service de Knative. Además, el servidor terminó el procesamiento y devolvió una respuesta.

   2025/11/27 17:24:21 Server responded with: &{ID:019ac4a0-c386-7cdc-9aad-d40fb8f98ae2 ContextID: Extensions:[] Metadata:map[] Parts:[{Text:Hello, world! Metadata:map[]}] ReferenceTasks:[] Role:agent TaskID:}

Recomendaciones para entornos de producción

• Nombre de dominio personalizado y HTTPS: No use directamente un nombre de dominio de prueba en un entorno de producción. Configure un nombre de dominio personalizado y habilite un certificado HTTPS para proteger la comunicación entre agentes.

• Optimización del arranque en frío: Si los agentes reciben llamadas con poca frecuencia, Knative escala las instancias a cero. Para evitar que la latencia del arranque en frío afecte la experiencia de interacción en la primera solicitud, configure el número mínimo de instancias (MinScale) o Configure reserved instances for Knative Services to reduce cold start latency.

Facturación

El complemento de Knative no genera cargos adicionales por sí mismo. Sin embargo, cada producto en la nube cobra por los recursos de cómputo, de red y demás recursos que usted consuma. Para obtener más información, consulte Cloud resource costs.