DEV Community

AWS Community Builders profile image xbill
xbill for AWS Community Builders

Posted on • Originally published at xbill999.Medium on

Deploying a Rust A2A Agent to AWS Lightsail

#awslightsail #aws #ferristhecrab #a2aprotocol

This article covers building Agent applications with the Agent to Agent (A2A) protocol using the Rust programming language. A minimally viable A2A Rust Agent application was debugged and validated locally. Then- the entire solution is deployed to AWS Lightsail.

Rust A2A? Isn’t that a Python Thing?

The bulk of A2A Agents are in Python. The A2A protocol is language independent.

Python has traditionally been the main coding language for ML and AI tools. The goal of this article is to provide a test bed for building, debugging, and deploying cross language applications.

So is this the Real Deal(TM)?

So what is different about this lab compared to all the others out there?

This is one of the first deep dives into a Rust A2A agent leveraging the standard Rust crates.

What is Rust?

Rust is a high performance, memory safe, compiled language:

Rust

Rust provides memory safe operations beyond C/C++ and also can provide exceptional performance gains as it is compiled directly to native binaries.

Rust Setup

Instructions to install Rust are available here:

Getting started

For a Linux like environment the command looks like this:

curl — proto ‘=https’ — tlsv1.2 -sSf https://sh.rustup.rs | sh
Enter fullscreen mode Exit fullscreen mode

Rust also depends on a working C compiler and OpenSSL setup. For a Debian 12/13 system — install the basic tools for development:

sudo apt install build-essential
sudo apt install libssl-dev
sudo apt install pkg-config
sudo apt-get install libudev-dev
sudo apt install make
sudo apt install git
Enter fullscreen mode Exit fullscreen mode

Antigravity CLI

Antigravity CLI is the follow-on successor to Gemini CLI- the terminal driven, agent assisted coding tool.

Full details on installing Antigravity CLI are here:

Getting Started with Antigravity CLI

Testing the Antigravity CLI Environment

Once you have all the tools in place- you can test the startup of Antigravity CLI.

You will need to authenticate with a Google Cloud Project or your Google Account:

agy
Enter fullscreen mode Exit fullscreen mode

This will start the interface:

AWS CLI

The AWS CLI provides a command line tool to directly access AWS services from your current environment. Full details on the CLI are available here:

Install Docker, AWS CLI, and the Lightsail Control plugin for containers

You can version check the tool after installation:

xbill@penguin:~/gemini-cli-aws/mcp-lightsai-rust-aws$ aws --version
aws-cli/2.34.43 Python/3.14.4 Linux/6.6.99-09128-g14e87a8a9b71 exe/x86_64.debian.12
Enter fullscreen mode Exit fullscreen mode

Amazon Lightsail

Amazon Lightsail is an easy-to-use virtual private server (VPS) provider and cloud platform designed by AWS for simpler workloads, offering developers pre-configured compute, storage, and networking for a low, predictable monthly price. It is ideal for hosting small websites, simple web apps, or creating development environments.

More information is available on the official site here:

Amazon's Simple Cloud Server | Amazon Lightsail

And this is the direct URL to the console:

https://lightsail.aws.amazon.com/ls/webapp/home/containers
Enter fullscreen mode Exit fullscreen mode

The Lightsail console will look similar to:

Where do I start?

The strategy for starting Rust A2A development is a incremental step by step approach.

First, the basic development environment is setup with the required system variables, and a working Antigravity CLI configuration.

Then, a Rust A2A agent is built, debugged, and tested locally.

Setup the Basic Environment

At this point you should have a working Python environment and a working Antigravity CLI installation. All of the relevant code examples and documentation is available in GitHub.

The next step is to clone the GitHub repository to your local environment:

cd ~
git clone https://github.com/xbill9/a2a-hello-world
cd poly-lightsail-rust-aws
Enter fullscreen mode Exit fullscreen mode

Then run init.sh from the cloned directory.

The script will attempt to determine your shell environment and set the correct variables:

source init.sh
Enter fullscreen mode Exit fullscreen mode

If your session times out or you need to re-authenticate- you can run the set_env.sh script to reset your environment variables:

source set_env.sh
Enter fullscreen mode Exit fullscreen mode

Variables like PROJECT_ID need to be setup for use in the various build scripts- so the set_env script can be used to reset the environment if you time-out.

Rust A2A Libraries

There are several crates that provide A2A support. This project uses the a2a-rs crate:

crates.io: Rust Package Registry

Here is a sample Cargo.TOML:

[dependencies]
tokio = { version = "^1.37.0", features = ["full"] }
anyhow = "1.0.86"
a2a-rs = { version = "0.2.0", features = ["full"] }
futures = "0.3"
async-trait = "0.1.80"
Enter fullscreen mode Exit fullscreen mode

Minimal System Information Tool Build

The first step is to build the basic tool directly with Rust. This allows the tool to be debugged and tested locally before adding the MCP layer.

First build the tool locally:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make
Building the Rust project...
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$
Enter fullscreen mode Exit fullscreen mode

then lint check the code:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make
Building the Rust project...
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.25s
xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$
Enter fullscreen mode Exit fullscreen mode

and run local tests:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make test
Running tests...
   Compiling a2a-server-rust v0.2.0 (/home/xbill/a2a-hello-world/poly-lightsail-rust-aws)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 2.31s
     Running unittests src/main.rs (target/debug/deps/a2a_server_rust-5d07a7739a477350)

running 2 tests
test tests::test_task_creation ... ok
test tests::test_simple_agent_handler_creation ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Enter fullscreen mode Exit fullscreen mode

The last step is to build the production version:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make release
Building Release...
    Finished `release` profile [optimized] target(s) in 0.29s
xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$
Enter fullscreen mode Exit fullscreen mode

The A2A server can be started locally:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make start
Starting the A2A Rust server on port 8080...
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.19s
     Running `target/debug/a2a-server-rust`
🚀 Starting A2A Rust Server
==============================
🌐 Starting HTTP server on 0.0.0.0:8080...
🔗 HTTP server listening on http://0.0.0.0:8080
2026-05-21T17:05:41.115301Z INFO main ThreadId(01) start{server.address=0.0.0.0:8080 server.has_auth=false}: a2a_rs::adapter::transport::http::server: Starting HTTP server
2026-05-21T17:05:41.115593Z INFO main ThreadId(01) start{server.address=0.0.0.0:8080 server.has_auth=false}: a2a_rs::adapter::transport::http::server: HTTP server listening on 0.0.0.0:8080
Enter fullscreen mode Exit fullscreen mode

Check The Local Agent Status

The project has a target to verify that the A2A server started:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make status
Checking AWS Lightsail service status for a2a-lightsail-rust-aws...
--------------------------------------------
| GetContainerServices |
+-------------+--------+-----------+-------+
| Deployment | Power | State | URL |
+-------------+--------+-----------+-------+
| ACTIVE | nano | RUNNING | None |
+-------------+--------+-----------+-------+
--- Service Status ---
Local (8080): ONLINE (A2A Rust Agent)
Remote (Cloud): ONLINE (A2A Rust Agent) - https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com
Enter fullscreen mode Exit fullscreen mode

A2A Inspector

The A2A Inspector provides a tool to verify A2A operations.

Background information is here:

Announcing the A2A Inspector: A UI tool for A2A protocol development

GitHub Repo is here:

GitHub - a2aproject/a2a-inspector: Validation Tools for A2A Agents

Verify The Local A2A Installation

Start the A2A Inspector and use localhost:8080:

You should see the details of the Agent Card:

{
  "capabilities": {
    "pushNotifications": false,
    "stateTransitionHistory": false,
    "streaming": true
  },
  "defaultInputModes": [
    "text"
  ],
  "defaultOutputModes": [
    "text"
  ],
  "description": "An A2A agent using the a2a-rs crate",
  "documentationUrl": "https://example.org/docs",
  "name": "A2A Rust Agent",
  "preferredTransport": "JSONRPC",
  "protocolVersion": "0.3.0",
  "provider": {
    "organization": "Example Organization",
    "url": "https://example.org"
  },
  "skills": [
    {
      "description": "Echoes back the user's message",
      "examples": [
        "Echo: Hello World"
      ],
      "id": "echo",
      "inputModes": [
        "text"
      ],
      "name": "Echo Skill",
      "outputModes": [
        "text"
      ],
      "tags": [
        "echo",
        "respond"
      ]
    }
  ],
  "url": "http://0.0.0.0:8080",
  "version": "1.0.0"
}
Enter fullscreen mode Exit fullscreen mode

Test the Local A2A Connection Locally

This step tests the A2A agent interactions with a test script:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make card
Fetching local agent card...
{
    "name": "A2A Rust Agent",
    "description": "An A2A agent using the a2a-rs crate",
    "url": "http://0.0.0.0:8080",
    "provider": {
        "organization": "Example Organization",
        "url": "https://example.org"
    },
    "version": "1.0.0",
    "protocolVersion": "0.3.0",
    "preferredTransport": "JSONRPC",
    "documentationUrl": "https://example.org/docs",
    "capabilities": {
        "streaming": false,
        "pushNotifications": false,
        "stateTransitionHistory": false
    },
    "defaultInputModes": [
        "text"
    ],
    "defaultOutputModes": [
        "text"
    ],
    "skills": [
        {
            "id": "echo",
            "name": "Echo Skill",
            "description": "Echoes back the user's message",
            "tags": [
                "echo",
                "respond"
            ],
            "examples": [
                "Echo: Hello World"
            ],
            "inputModes": [
                "text"
            ],
            "outputModes": [
                "text"
            ]
        }
    ]
}
Enter fullscreen mode Exit fullscreen mode

and the A2A can be tested:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make a2a-local
Running local A2A echo test...
🚀 Testing A2A Echo Skill at http://localhost:8080
💬 Sending message: 'Hello from the test program!'
✅ Received echo: 'Echo: Hello from the test program!'
🌟 Success! The echo skill is working correctly.
xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$
Enter fullscreen mode Exit fullscreen mode

So What Just Happened?

The Rust A2A agent was started locally. This agent provided a standard A2A agent card. Then, test scripts performed a A2A skills call against the locally running Rust A2A server. Because the A2A server in Rust provides standard tools- the A2A inspector could connect. The actual implementation language of the A2A code does not matter — as long as standard services are exposed.

Deploy to AWS Lightsail

Once the Agent has been validated and tested locally- the solution can be deployed to AWS Lightsail. Run the deploy target in the Makefile:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make deploy
Enter fullscreen mode Exit fullscreen mode

Once the build is done — you can check the status:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make status
Checking AWS Lightsail service status for a2a-lightsail-rust-aws...
--------------------------------------------
| GetContainerServices |
+-------------+--------+-----------+-------+
| Deployment | Power | State | URL |
+-------------+--------+-----------+-------+
| ACTIVE | nano | RUNNING | None |
+-------------+--------+-----------+-------+
--- Service Status ---
Local (8080): ONLINE (A2A Rust Agent)
Remote (Cloud): ONLINE (A2A Rust Agent) - [https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com](https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com)
xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$
Enter fullscreen mode Exit fullscreen mode

and get the endpoint:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make endpoint
https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com/
Enter fullscreen mode Exit fullscreen mode

Verify the Cloud Run Service

The Rust A2A service will be visible from the Lightsail console:

Testing AWS Deployment

The Makefile has several tools for validating the remote A2A server.

First — you can get the remote Agent card:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make card-remote
Fetching remote agent card...
{
    "name": "A2A Rust Agent",
    "description": "An A2A agent using the a2a-rs crate",
    "url": "http://0.0.0.0:8080",
    "provider": {
        "organization": "Example Organization",
        "url": "https://example.org"
    },
    "version": "1.0.0",
    "protocolVersion": "0.3.0",
    "preferredTransport": "JSONRPC",
    "documentationUrl": "https://example.org/docs",
    "capabilities": {
        "streaming": false,
        "pushNotifications": false,
        "stateTransitionHistory": false
    },
    "defaultInputModes": [
        "text"
    ],
    "defaultOutputModes": [
        "text"
    ],
    "skills": [
        {
            "id": "echo",
            "name": "Echo Skill",
            "description": "Echoes back the user's message",
            "tags": [
                "echo",
                "respond"
            ],
            "examples": [
                "Echo: Hello World"
            ],
            "inputModes": [
                "text"
            ],
            "outputModes": [
                "text"
            ]
        }
    ]
}
Enter fullscreen mode Exit fullscreen mode

and run a basic test:

xbill@penguin:~/a2a-hello-world/poly-lightsail-rust-aws$ make a2a-remote
Running remote A2A echo test...
🚀 Testing A2A Echo Skill at https://a2a-lightsail-rust-aws.6wpv8vensby5c.us-east-1.cs.amazonlightsail.com
💬 Sending message: 'Hello from the test program!'
✅ Received echo: 'Echo: Hello from the test program!'
🌟 Success! The echo skill is working correctly.
Enter fullscreen mode Exit fullscreen mode

Crates.io

The full package is available on GitHub and crates.io:

crates.io: Rust Package Registry

The package details are here:

Summary

A complete A2A server was built using Rust. Basic validation was done with the A2A inspector. Next, test scripts were built that directly called the Rust A2A server. Finally, the complete solution was deployed to Amazon Lightsail.

Top comments (0)