Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/The-Swarm-Corporation/SwarmsXGCP
Deploy your agents on Cloud Run!
https://github.com/The-Swarm-Corporation/SwarmsXGCP
ai gcp google googlecloud ml multi-agent swarms
Last synced: 3 days ago
JSON representation
Deploy your agents on Cloud Run!
- Host: GitHub
- URL: https://github.com/The-Swarm-Corporation/SwarmsXGCP
- Owner: The-Swarm-Corporation
- License: mit
- Created: 2025-01-02T21:00:05.000Z (6 days ago)
- Default Branch: main
- Last Pushed: 2025-01-02T21:44:32.000Z (6 days ago)
- Last Synced: 2025-01-02T22:25:06.761Z (6 days ago)
- Topics: ai, gcp, google, googlecloud, ml, multi-agent, swarms
- Language: Python
- Homepage: https://swarms.ai
- Size: 22.5 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
- awesome_ai_agents - Swarmsxgcp - Deploy your agents on Cloud Run! (Building / Deployment)
- awesome_ai_agents - Swarmsxgcp - Deploy your agents on Cloud Run! (Building / Deployment)
README
# Deploying Swarms on Google Cloud Platform (GCP) Cloud Run
[](https://discord.gg/agora-999382051935506503) [](https://www.youtube.com/@kyegomez3242) [](https://www.linkedin.com/in/kye-g-38759a207/) [](https://x.com/kyegomezb)
[](https://github.com/The-Swarm-Corporation/Legal-Swarm-Template)
[](https://github.com/kyegomez/swarms)
## Introduction
This guide provides a comprehensive walkthrough for deploying a **Swarms-based application** on **Google Cloud Platform (GCP) Cloud Run**. It covers setup, Dockerization, deployment, and best practices to ensure high availability, scalability, and security. This document assumes an enterprise audience with the goal of deploying production-ready applications.
---
## Prerequisites
Before starting, ensure you have the following:
### 1. **GCP Account and Project Setup**
- Access to a GCP account.
- A GCP project created for this deployment.
- Billing enabled on the project.
### 2. **Tools Installed**
- **Google Cloud SDK** ([Install Guide](https://cloud.google.com/sdk/docs/install))
- **Docker** ([Install Guide](https://docs.docker.com/get-docker/))
- **Python 3.8 or higher**
### 3. **API Enablement**
Enable the following APIs in your GCP project:
- **Cloud Run API**
- **Container Registry API** or **Artifact Registry API**
### 4. **Code Structure**
Your Swarms project should have the following directory structure:
```plaintext
project-root/
├── api/
│ └── api.py
├── requirements.txt
├── Dockerfile
└── .dockerignore
```
---
## Step 1: Project Initialization
### 1.1 Clone or Create the Swarms Application
Ensure your application follows best practices for API design and uses **FastAPI** or an equivalent framework. Below is an example of `api.py`:
```python
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Welcome to Swarms API on GCP Cloud Run!"}
```
### 1.2 Create the `requirements.txt`
List all Python dependencies in the `requirements.txt` file. For example:
```plaintext
fastapi
uvicorn[standard]
```
### 1.3 Create a `.dockerignore` File
Optimize your Docker build process by excluding unnecessary files:
```plaintext
__pycache__/
*.pyc
*.pyo
*.pyd
.env
.DS_Store
```
---
## Step 2: Create the Dockerfile
The `Dockerfile` is essential for containerizing your application. Below is an enterprise-grade example:
```dockerfile
# Base image
FROM python:3.9-slim
# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
# Set working directory
WORKDIR /app
# Copy application files
COPY api /app/api
COPY requirements.txt /app
# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Expose port for the application
EXPOSE 8080
# Run the FastAPI application with Uvicorn
CMD ["uvicorn", "api.api:app", "--host", "0.0.0.0", "--port", "8080"]
```
---
## Step 3: Build and Test the Docker Image
### 3.1 Build the Docker Image
Run the following command from the root of your project:
```bash
docker build -t swarms-api .
```
### 3.2 Test Locally
To verify that your application runs correctly:
```bash
docker run -p 8080:8080 swarms-api
```
Access the API by visiting `http://localhost:8080` in your browser.
---
## Step 4: Push the Docker Image to Google Container Registry
### 4.1 Authenticate with GCP
Login and configure your project:
```bash
gcloud auth login
gcloud config set project [PROJECT_ID]
```
### 4.2 Tag the Docker Image
Tag your Docker image for GCP Container Registry:
```bash
docker tag swarms-api gcr.io/[PROJECT_ID]/swarms-api
```
### 4.3 Push the Image to Container Registry
Push the image to GCP:
```bash
docker push gcr.io/[PROJECT_ID]/swarms-api
```
---
## Step 5: Deploy to Cloud Run
### 5.1 Deploy the Application
Use the following command to deploy your containerized application to Cloud Run:
```bash
gcloud run deploy swarms-api \
--image gcr.io/[PROJECT_ID]/swarms-api \
--platform managed \
--region [REGION] \
--allow-unauthenticated
```
Replace:
- `[PROJECT_ID]` with your GCP project ID.
- `[REGION]` with your desired deployment region (e.g., `us-central1`).
### 5.2 Verify Deployment
After deployment, you will receive a public URL. Visit the URL to confirm that your application is running.
---
## Step 6: Implement Enterprise-Level Best Practices
### 6.1 Security Best Practices
- **Authentication:** Use **IAM** to restrict access to Cloud Run services.
- **Environment Variables:** Use GCP **Secret Manager** for managing sensitive data like API keys.
- **Private Networking:** Deploy Cloud Run services within a **VPC** for secure communication.
### 6.2 Scalability and Availability
- **Auto-scaling:** Cloud Run automatically scales based on traffic. Ensure your application can handle multiple concurrent requests.
- **Concurrency Settings:** Tune the `--max-instances` and `--concurrency` flags to optimize resource usage.
### 6.3 Logging and Monitoring
Enable logging and monitoring for better observability:
```bash
gcloud logging read "resource.type=cloud_run_revision" --limit 100
```
Use **Cloud Monitoring** dashboards to visualize metrics like request latency and error rates.
---
## Step 7: Continuous Integration and Deployment (CI/CD)
### 7.1 Configure CI/CD Pipeline
Integrate with a CI/CD tool like **GitHub Actions**, **GitLab CI**, or **Google Cloud Build**. Below is an example GitHub Actions workflow:
```yaml
name: GCP Cloud Run Deployment
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Set up Cloud SDK
uses: google-github-actions/setup-gcloud@v1
with:
project_id: ${{ secrets.GCP_PROJECT_ID }}
service_account_key: ${{ secrets.GCP_SA_KEY }}
- name: Authenticate Docker with GCP
run: gcloud auth configure-docker
- name: Build and push Docker image
run: |
docker build -t gcr.io/${{ secrets.GCP_PROJECT_ID }}/swarms-api .
docker push gcr.io/${{ secrets.GCP_PROJECT_ID }}/swarms-api
- name: Deploy to Cloud Run
run: |
gcloud run deploy swarms-api \
--image gcr.io/${{ secrets.GCP_PROJECT_ID }}/swarms-api \
--platform managed \
--region us-central1 \
--allow-unauthenticated
```
---
## Troubleshooting
### 8.1 Common Issues
| Error | Solution |
|----------------------------------------|---------------------------------------------|
| **Permission denied** | Ensure correct IAM permissions for the user |
| **Container fails to start** | Check application logs in Cloud Run console |
| **High latency or errors under load** | Optimize concurrency settings and code |
### 8.2 Debugging Tips
- Use `gcloud run logs read` to view logs in real-time.
- Test APIs locally using tools like Postman or cURL.
---
## Conclusion
By following this guide, you have successfully deployed a Swarms application on GCP Cloud Run, leveraging enterprise-grade best practices for scalability, security, and CI/CD integration. For further improvements, explore advanced topics like **service meshes**, **multi-region deployments**, and **custom domains**.
For questions or contributions, contact [[email protected]].