Haven't read Part 1? Start with Building Orbit: A Lightweight Container Orchestrator in Rust to learn about our journey's beginning.

In our previous article, we introduced Orbit, our lightweight container orchestrator built in Rust. Since then, we've made significant improvements driven by both community feedback and production requirements. Let's dive into the technical evolution that's making Orbit even more powerful and efficient.

Community-Driven Development

One of the most exciting aspects of Orbit's development has been the community engagement. A perfect example is our implementation of CoDel (Controlled Delay) for scaling decisions, which came directly from a community member's suggestion on Medium. We're also grateful to community members like Josselin Chevalay who contributed the pull_policy feature in our latest release, allowing control over container image pulling behavior. This collaborative approach will continue to help shape Orbit's feature set and technical direction.

Technical Evolution: Key Improvements

1. CoDel (Controlled Delay) - Inspired Scaling: Latency-Driven Container Orchestration

Unlike traditional orchestrators that rely solely on CPU and memory metrics, we've implemented CoDel-based/inspired scaling - a feature not natively available in Kubernetes or other major orchestrators. Here's how it works:

pub struct CoDelMetrics {
    service_name: String,
    sojourn_times: VecDeque<(Instant, Duration)>,
    first_above_time: Option<Instant>,
    last_scale_time: Instant,
    config: CoDelConfig,
}

name: adaptive-scaling
instance_count:
  min: 2
  max: 10

# CoDel-inspired adaptive scaling based on request latency
codel:
  target: 100ms                   # Target latency threshold
  interval: 1s                    # Interval for checking delays
  consecutive_intervals: 3        # Number of intervals above target before scaling
  max_scale_step: 1              # Maximum instances to scale up at once
  scale_cooldown: 30s            # Minimum time between scaling actions
  overload_status_code: 503      # Return 503 when overloaded

# Fine-tune scaling behavior
scaling_policy:
  cooldown_duration: 60s         # Wait time between scaling actions
  scale_down_threshold_percentage: 50.0  # Scale down if usage below 50%

spec:
  containers:
    - name: main
      image: airpipeio/infoapp:latest
      ports:
        - port: 80
          node_port: 4335

The CoDel inspired implementation monitors request latency and makes intelligent scaling decisions based on both immediate and historical performance data. Benefits include:

• More responsive scaling based on actual service performance

• Better handling of latency spikes

• Prevention of unnecessary scale-ups during temporary load increases

Note that this is just our initial implementation, and we will continue to improve where possible and perhaps rename when appropriate.

Key Differences from Traditional CoDel:

• Service-Level Application:

  • Our implementation applies CoDel principles at the service level rather than packet level

  • Uses request latency instead of packet sojourn time

  • Focuses on scaling rather than packet dropping

• State Management:

  • This is simpler than traditional CoDel's state machine.

pub struct CoDelMetrics {
    sojourn_times: VecDeque<(Instant, Duration)>,
    first_above_time: Option<Instant>,
    last_scale_time: Instant,
}

2. Health Monitoring

We've added the usual health monitoring with TCP health checks:

pub struct HealthCheckConfig {
    pub startup_timeout: Duration,
    pub startup_failure_threshold: u32,
    pub liveness_period: Duration,
    pub liveness_failure_threshold: u32,
    pub tcp_check: Option<TcpHealthCheck>,
}

This system provides:

• Configurable health check parameters

• TCP-level connectivity verification

• Granular control over failure thresholds

• Separate startup and liveness checks

3. Performance Optimizations

We've made several low-level optimizations to improve performance:

Switching to FxHashMap/FxHashSet

use rustc_hash::{FxHashMap, FxHashSet};

pub static INSTANCE_STORE: OnceLock<
    Arc<RwLock<FxHashMap<String, FxHashMap<Uuid, InstanceMetadata>>>>
> = OnceLock::new();

By replacing standard HashMap with FxHashMap:

• Reduced memory overhead

• Faster hash computation

• Better performance for string keys

• Lower collision rates in our specific use cases

4. Improved Resource Management

We've implemented a more sophisticated resource management system:

pub struct ResourceThresholds {
    pub cpu_percentage: Option<u8>,
    pub cpu_percentage_relative: Option<u8>,
    pub memory_percentage: Option<u8>,
    pub metrics_strategy: PodMetricsStrategy,
}

This allows for:

• Fine-grained control over resource utilization

• Better handling of CPU quota management

• More accurate memory tracking

• Customizable metrics aggregation strategies

Real-World Impact

These improvements have had significant real-world impact:

• 30% reduction in unnecessary scaling operations

• More stable performance under varying load conditions

• Reduced resource usage in the orchestrator itself

• Better handling of microservices with varying performance characteristics

• Still managed to retain a <5MB binary size footprint

What's Next: Decentralized Clustering!?

We're excited to explore our next major development focus: a decentralized clustering solution. This will allow Orbit to:

• Operate without a central control plane

• Provide better resilience in edge deployments

• Enable peer-to-peer node coordination

• Support dynamic cluster topology changes

We have some initial ideas on how to design the solution, so please follow for our next update to see how we hope to make this happen!

Building at Scale with Air Pipe

While Orbit handles container orchestration, it's just one piece of the puzzle. At Air Pipe, we're building a comprehensive platform for creating scalable, resilient APIs, integrations, and workflows. Our platform enables you to:

• Build and deploy scalable APIs with minimal boilerplate

• Create robust integration workflows

• Implement resilient data processing pipelines

• Leverage edge computing capabilities

If you're building distributed systems or scalable applications, visit airpipe.io to learn how our platform can accelerate your development.

Get Involved

We're building Orbit in the open and value community input. Whether you're interested in the technical details or want to contribute to our upcoming clustering features:

• Star us on GitHub

• Join our Discord community

• Visit Air Pipe

• Follow our progress as we build the decentralized clustering solution

Stay tuned for our next technical deep-dive where we'll explore the architecture of our decentralized clustering approach!

Update: Check out Part 2 of this series where we explore Orbit's evolution including latency-based container scaling, TCP health checks, and performance optimizations.

Why We Started

Our journey began with a specific need at Air Pipe. Running a shared-nothing architecture at the edge, we needed a simple way to scale HTTP/TCP based containers without the overhead of complex infrastructure or additional dependencies. We wanted something that could be deployed as a single binary, yet provide robust container management capabilities.

The existing solutions didn't quite fit:

• Kubernetes: Too complex for our edge use case, with a large learning curve and resource footprint

• Docker Swarm: Too basic, lacking crucial features like autoscaling

• Other solutions: Either too complex or too tightly coupled with specific cloud providers or vendors

Starting Simple: Basic Container Management

We started with the basics - a simple Rust application that could manage individual containers. The choice of Rust was deliberate:

• Memory safety without garbage collection

• High performance and low resource usage

• Strong type system and excellent concurrency model

• Growing ecosystem of libraries and tools

Our first version could do basic container operations:

async fn start_containers(
    &self,
    service_name: &str,
    containers: &Vec<Container>,
) -> Result<Vec<(String, String)>> {
    // Basic container startup logic
}

Evolution to Pod-Based Architecture

As we developed the system, we realized that managing groups of containers together (pods) would provide better isolation and resource management. This led to a more sophisticated container management system:

pub struct InstanceMetadata {
    pub uuid: Uuid,
    pub created_at: SystemTime,
    pub network: String,
    pub containers: Vec<ContainerMetadata>,
    pub image_hash: HashMap<String, String>,
}

This structure allowed us to track related containers and their metadata together, making operations like scaling and updates more coherent.

The Game Changer: Integrating Pingora

One of our most significant technical decisions was choosing Cloudflare's Pingora framework for our proxy layer. This wasn't just about load balancing - it was about building a robust, high-performance proxy system that could handle production workloads efficiently.

Why Pingora?

• Written in Rust, aligning with our technology stack

• Battle-tested at Cloudflare's scale

• Excellent performance characteristics

• Built-in health checking and automatic failover

The integration looked something like this:

name: web-service
instance_count:
  min: 2
  max: 5
spec:
  containers:
    - name: web
      image: airpipeio/infoapp:latest
      ports:
        - port: 80
          node_port: 30080  # This enables Pingora proxy

Adding Intelligence: Resource-Based Autoscaling

One of our proudest features is the intelligent autoscaling system. Instead of just scaling based on simple metrics, we implemented a sophisticated resource monitoring and scaling system:

resource_thresholds:
  cpu_percentage: 80         # CPU usage threshold
  cpu_percentage_relative: 90 # CPU usage relative to limit
  memory_percentage: 85      # Memory usage threshold
  metrics_strategy: max      # Strategy for pod metrics

The system continuously monitors these metrics and makes scaling decisions based on configurable thresholds. Here's a practical example:

name: demo-service
instance_count:
  min: 2
  max: 5
memory_limit: "1Gi"
cpu_limit: "1.0"
resource_thresholds:
  cpu_percentage: 80
  memory_percentage: 85
spec:
  containers:
    - name: infoapp
      image: airpipeio/infoapp:latest
      ports:
        - port: 80
          node_port: 30080
      memory_limit: "512Mi"
      cpu_limit: "0.5"

In this configuration, if CPU usage exceeds 80% or memory usage exceeds 85% across instances, Orbit automatically scales up the service (up to the max instance count). When resource usage decreases, it scales down gracefully while maintaining the minimum instance count.

Where We Are Today

Today, Orbit stands as a testament to what's possible when you focus on solving a specific problem well. It's a single binary under 5MB that provides:

• Automated container scaling

• Service discovery

• High-performance proxying

• Volume management

• Rolling updates

• Prometheus metrics integration

Try It Yourself

Want to see Orbit in action? Here's a simple example to get started:

1. Download Orbit from our releases

2. Create a configuration file (e.g., web-service.yml):

name: web-service
instance_count:
  min: 2
  max: 5
resource_thresholds:
  cpu_percentage: 80
  memory_percentage: 85
spec:
  containers:
    - name: web
      image: airpipeio/infoapp:latest
      ports:
        - port: 80
          node_port: 30080

3. Start Orbit: orbit -c /path/to/configs

Visit http://localhost:30080 to see your service in action, and watch Orbit automatically manage scaling based on resource usage.

Looking Forward

We're continuing to evolve Orbit based on real-world usage and community feedback. Our focus remains on maintaining simplicity while adding powerful features that make container orchestration easier and more efficient.

Want to learn more or contribute? Check out our GitHub repository or join our Discord community.

Continue Reading: Explore Part 2 of this series to see how Orbit has evolved with new features like latency-based scaling and performance optimizations.

About Air Pipe

Orbit is just one piece of the puzzle in our mission to simplify and improve the software development lifecycle. At Air Pipe, we're building tools and platforms that make it easier to build, test, and deploy applications. Our shared-nothing architecture and edge computing approach allows for highly efficient and scalable deployments.

Want to learn more about how Air Pipe can help streamline your development workflow? Visit airpipe.io to discover our complete suite of development tools and solutions. See how our platform can help you build better software, faster.

That’s where Air Pipe comes in. Air Pipe is a fast, scalable, and secure API platform that simplifies the process of building, deploying, and managing APIs. In this guide, we’ll show you how to leverage Google Gemini AI’s API and Air Pipe to create your own AI-powered API in just a few easy steps.

Whether you're looking to automate tasks, enhance your app with AI, or streamline data processing, this tutorial will walk you through generating a Google Gemini API key and configuring a simple yet powerful API using Air Pipe. By the end, you'll have a fully functioning API ready to deploy—allowing you to integrate cutting-edge AI with ease.

Let’s dive in and build something amazing with Google Gemini and Air Pipe!

Step-by-Step Guide to Build Your Own AI API

This tutorial will focus on the cloud platform deployment but will also work seamlessly for self hosted deployments, you can learn how to self host here → https://docs.airpipe.io/docs/tutorial/setup .

Prerequisites:

• Sign up or log in to Air Pipe.

• Google account and API Key

Step 0: Get your Google Gemini API Key

Navigate to https://aistudio.google.com/app/apikey and select “Create API Key”.

Create a new project if you have not already.

For production deployments we understand your API keys are sensitive, we provide encrypted variable (secret) support https://docs.airpipe.io/docs/configuration/managed-variables .

The examples below will utilize this system storing the key as gemini-key which is then accessed with a|ap_var::gemini-key| .

Other secret stores are also supported.

Step 1: Create your Configuration

Once signed in to your Air Pipe account, head to Configurations > Add New.

Step 2: Create a HTTP POST interface

In the YAML editor paste the below example. Here we simply define a HTTP POST interface and route called gemini/query . We further define our first action to check the body of the payload for a text attribute to exist and assert that it must be less than 20 characters (this is a simple example for illustrative purposes).

Assertions are important to understand as we can control what the user is allowed to input, and then we can further control the outcome of the API and action with the configured tests .

name: AskGemini

interfaces:
  gemini/query: # http route will be defaulted to this interface name
    method: POST
    input: a|body
    output: http

    actions:
      - name: CheckBody
        input: a|body # access the post body as the input to assert
        assert:
          tests:
            - value: text
              is_not_null: true
              is_less_than: 20 # limit the amount of characters

Step 3: Retrieving the full Gemini Response

Let’s extend the configuration and pass the text attribute to the Google Gemini API, we do this using a|CheckBody::text| in our configuration. We will also use workflow control, to ensure the CheckBody action succeeds before querying Google Gemini AI with run_when_succeeded.

We are using Action Variables to dynamically substitute the value into the payload, see our docs on variable substitutions for further details and options.

name: AskGemini

interfaces:
  gemini/query:
    method: POST
    input: a|body
    output: http

    actions:
      - name: CheckBody
        input: a|body
        assert:
          tests:
            - value: text
              is_not_null: true
              is_less_than: 20 # limit the amount of characters

      - name: QueryGemini
        run_when_succeeded: [previous] # only run after CheckBody succeeds
        http: 
          url: https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=a|ap_var::gemini-key|
          method: POST
          headers:
            content-type: application/json
          body: | # substitute the 'text' we just validated in 'CheckBody' into the body payload
            {"contents":[{"parts":[{"text":"a|CheckBody::text|"}]}]}

Step 4: Deploy and Test

• Set your permission as USER_WITH_PUBLIC_READ

• Select Deploy to Staging and Deploy to Production and hit create.

Use your favorite API testing tool, or do a curl to your endpoints, let’s try the gemini/query route, make sure you update your organization uuid in the route.

You can find your organization uuid under Configurations or in your Organization Settings.

• Send a HTTP POST with a JSON payload eg. {"text": "tell me about dogs"} to gemini/query to retrieve the response.

• Send a HTTP POST with a JSON payload eg. {"text": "tell me about really big dogs"} to test the length condition triggering a failure and preventing the QueryGemini action from proceeded.

https://api.airpipe.io/YOUR-ORGANIZATION-UUID/production/gemini/query

curl --location 'https://api.airpipe.io/YOUR-ORGANIZATION-UUID/production/gemini/query' \
--header 'Content-Type: application/json' \
--data '{
    "text": "tell me about dogs"
}'

Example response:

{
    "data": {
        "CheckBody": {
            "time.ms": 0,
            "data": {
                "text": "tell me about dogs"
            },
            "message": "success"
        },
        "QueryGemini": {
            "time.ms": 4180,
            "data": {
                "status": 200,
                "headers": {
                    "content-type": "application/json; charset=UTF-8",
                    "vary": "Origin,Accept-Encoding",
                    "date": "Sun, 29 Sep 2024 15:40:42 GMT",
                    "server": "scaffolding on HTTPServer2",
                    "cache-control": "private",
                    "x-xss-protection": "0",
                    "x-frame-options": "SAMEORIGIN",
                    "x-content-type-options": "nosniff",
                    "server-timing": "gfet4t7; dur=4016",
                    "alt-svc": "h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000",
                    "accept-ranges": "none"
                },
                "body": {
                    "candidates": [
                        {
                            "content": {
                                "parts": [
                                    {
                                        "text": "## Dogs: Man's Best Friend, and More!\n\nDogs, those furry, wagging companions, have been by our side for thousands of years. They're more than just pets; they're loyal friends, helpful assistants, and sometimes even family members. Let's delve into what makes dogs so special:\n\n**Origins and History:**\n\n* **Wolf Ancestry:** Domestic dogs are descended from wolves, with the earliest evidence of domestication dating back 15,000 years.\n* **Evolution:** Over time, dogs evolved to work alongside humans in various roles like hunting, herding, and guarding. This led to the development of different breeds, each with unique physical and behavioral characteristics.\n\n**Breed Diversity:**\n\n* **Over 300 Breeds:** The world boasts a fascinating variety of dog breeds, each with a distinct appearance, temperament, and purpose.\n* **Classifications:** Breeds are categorized based on their size, coat type, and intended roles, like working, herding, sporting, and companion dogs. \n* **Unique Traits:** From tiny Chihuahuas to massive Great Danes, each breed has its own personality and quirks.\n\n**Personality and Behavior:**\n\n* **Social Creatures:** Dogs are highly social animals, forming strong bonds with their human families.\n* **Intelligence and Trainability:** Many dogs are incredibly intelligent and capable of learning complex commands and tricks. \n* **Emotionally Expressive:** Dogs communicate their emotions through body language, vocalizations, and facial expressions.\n* **Individual Differences:**  While certain breeds tend to have specific temperament traits, each dog is an individual with their own unique personality.\n\n**Health and Care:**\n\n* **Lifespan:** Depending on the breed, dogs can live anywhere from 10 to 20 years.\n* **Nutrition and Exercise:** Dogs require a balanced diet and regular exercise to stay healthy and happy.\n* **Grooming:** Different breeds have different grooming needs, ranging from occasional brushing to daily baths.\n* **Veterinary Care:** Regular checkups, vaccinations, and preventative measures are crucial for maintaining good health.\n\n**Beyond Companionship:**\n\n* **Working Dogs:** Dogs play vital roles in various professions, including law enforcement, search and rescue, assistance for individuals with disabilities, and therapy work.\n* **Emotional Support:** Dogs provide emotional support, reduce stress, and improve mental well-being.\n* **Family Members:** For many families, dogs become cherished members, offering unconditional love, companionship, and joy.\n\n**Getting a Dog:**\n\n* **Research:** Before getting a dog, consider your lifestyle, living situation, and the breed's temperament and care requirements.\n* **Adopting:** Consider adopting a dog from a shelter or rescue organization, giving a loving home to a dog in need.\n* **Responsible Ownership:** Be prepared to provide a dog with a safe, loving environment, proper care, and training.\n\nDogs enrich our lives in countless ways. They offer companionship, loyalty, and unconditional love, making them truly deserving of their title: \"Man's Best Friend.\" \n"
                                    }
                                ],
                                "role": "model"
                            },
                            "finishReason": "STOP",
                            "index": 0,
                            "safetyRatings": [
                                {
                                    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
                                    "probability": "NEGLIGIBLE"
                                },
                                {
                                    "category": "HARM_CATEGORY_HATE_SPEECH",
                                    "probability": "NEGLIGIBLE"
                                },
                                {
                                    "category": "HARM_CATEGORY_HARASSMENT",
                                    "probability": "NEGLIGIBLE"
                                },
                                {
                                    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
                                    "probability": "NEGLIGIBLE"
                                }
                            ]
                        }
                    ],
                    "usageMetadata": {
                        "promptTokenCount": 4,
                        "candidatesTokenCount": 642,
                        "totalTokenCount": 646
                    }
                }
            }
        }
    }
}

Step 5: Clean up the Gemini Response

As you can see with the response returned above, Google Gemini returns a lot of additional data you do not need to expose to your end users. We can use post_transforms with extract_value to target the text attribute to return.

Go to Configurations and find your AskGemini configuration and click update, and paste the below.

View Transforms & Functions for further ways to manipulate your data.

name: AskGemini

interfaces:
  gemini/query:
    method: POST
    input: a|body
    output: http

    actions:
      - name: CheckBody
        input: a|body
        assert:
          tests:
            - value: text
              is_not_null: true
              is_less_than: 20 # limit the amount of characters

      - name: QueryGemini
        run_when_succeeded: [previous] # only run after CheckBody succeeds
        http: 
          url: https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=a|ap_var::gemini-key|
          method: POST
          headers:
            content-type: application/json
          body: | # substitute the 'text' we just validated in 'CheckBody' into the body payload
            {"contents":[{"parts":[{"text":"a|CheckBody::text|"}]}]} 
        post_transforms:
          - extract_value: ".body.candidates[0].content.parts[0].text"

Example response:

    {
        "data": {
            "CheckBody": {
                "time.ms": 0,
                "data": {
                    "text": "tell me about dogs"
                },
                "message": "success"
            },
            "QueryGemini": {
                "time.ms": 4111,
                "data": "## Dogs: The Best Friends of Humans\n\nDogs, also known as **Canis lupus familiaris**, are domesticated mammals that have been companions to humans for thousands of years. Their loyalty, intelligence, and playful nature have made them beloved pets worldwide.\n\n**Here's a breakdown of some key aspects of dogs:**\n\n**Physical Characteristics:**\n\n* **Size:** Dogs come in a wide range of sizes, from tiny Chihuahuas to massive Great Danes.\n* **Coat:** Dog coats vary in length, texture, and color. Some have short, smooth coats, while others have long, fluffy fur.\n* **Tail:** Most dogs have tails that wag when they are happy. Tail length and shape can vary depending on the breed.\n* **Ears:** Dog ears come in various shapes and sizes, from floppy to erect.\n* **Snout:** Dogs have a strong sense of smell, which is aided by their long, pointed snouts.\n\n**Behavior:**\n\n* **Intelligence:** Dogs are highly intelligent animals, capable of learning complex commands and tasks.\n* **Socialization:** Dogs are social animals that thrive on interaction with humans and other dogs.\n* **Loyalty:** Dogs are known for their loyalty and devotion to their owners.\n* **Playfulness:** Dogs are playful animals that enjoy games and activities.\n* **Training:** Dogs are highly trainable, and with proper training, they can learn a wide range of behaviors.\n\n**Breeds:**\n\nThere are over 300 recognized dog breeds, each with its own unique physical characteristics and temperament. Some popular breeds include:\n\n* **Golden Retriever:** Friendly, intelligent, and eager to please.\n* **Labrador Retriever:** Loyal, playful, and known for their love of water.\n* **German Shepherd:** Intelligent, loyal, and protective.\n* **Poodle:** Intelligent, hypoallergenic, and known for their curly coats.\n* **French Bulldog:** Affectionate, playful, and known for their bat ears.\n\n**Health:**\n\n* **Lifespan:** The average lifespan of a dog is 10-13 years, but some breeds can live longer.\n* **Diet:** Dogs need a balanced diet that is rich in protein, carbohydrates, and essential nutrients.\n* **Exercise:** Most dogs need regular exercise to stay healthy and happy.\n* **Veterinary care:** Regular veterinary checkups and vaccinations are essential for maintaining a dog's health.\n\n**Benefits of Owning a Dog:**\n\n* **Companionship:** Dogs provide companionship and unconditional love.\n* **Stress relief:** Owning a dog can help reduce stress and anxiety.\n* **Exercise and activity:** Dogs encourage their owners to be more active.\n* **Improved mental health:** Studies have shown that owning a dog can improve mental health.\n* **Protection:** Some breeds are known for their protective instincts.\n\n**Conclusion:**\n\nDogs are wonderful companions that offer many benefits to their owners. Whether you're looking for a loyal friend, a playful companion, or a furry family member, there's a dog breed out there for everyone."
            }
        }
    }

Step 6: Restricting and manipulating the text prompt

As you’ve seen before we can restrict the input text with certain conditions. However we may also want to restrict what we are requesting from Google Gemini AI, or want it to behave or respond in a particular way.

In our example lets say we want a maximum of 100 characters returned only.

We can simply modify the body we are sending to Google Gemini AI to prefix the text with some additional text eg. Your response to the following question should be less than 100 characters: a|CheckBody::text| .

 {"contents":[{"parts":[{"text":"Your response to the following question should be less than 100 characters: a|CheckBody::text|"}]}]}

Complete example:

name: AskGemini

interfaces:
  gemini/query:
    method: POST
    input: a|body
    output: http

    actions:
      - name: CheckBody
        input: a|body
        assert:
          tests:
            - value: text
              is_not_null: true
              is_less_than: 20 # limit the amount of input characters

      - name: QueryGemini
        run_when_succeeded: [previous] # only run after CheckBody succeeds
        http: # store your gemini key in the hosted variables or substitute a|ap_var::gemini-key| with your key if testing # https://aistudio.google.com/app/apikey
          url: https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=a|ap_var::gemini-key|
          method: POST
          headers:
            content-type: application/json
          body: | # substitute the 'text' we just validated in 'CheckBody' into the body payload
            {"contents":[{"parts":[{"text":"Your response to the following question should be less than 100 characters: a|CheckBody::text|"}]}]} 
        post_transforms:
          - extract_value: ".body.candidates[0].content.parts[0].text"

Example response:

    {
        "data": {
            "CheckBody": {
                "time.ms": 0,
                "data": {
                    "text": "tell me about dogs"
                },
                "message": "success"
            },
            "QueryGemini": {
                "time.ms": 1907,
                "data": "Dogs are loyal, furry companions known for their intelligence and love. 🐶 \n"
            }
        }
    }

Now you finally have a nice clean response from Google Gemini AI for your end users to consume. We have securely stored the API key, validated the input text, cleaned the data and effectively sandboxed the output response.

So with that you’re done! Whats Next?

Air Pipe provides you a fast, consistent and robust development experience that you can continue extending with confidence across anything you build.

You can further extend your configuration to connect to databases and other endpoints all in the one configuration with workflow controls at your disposal.

See:

• Databases

• Tutorial

• Configuration

• Validating Data

Performance and Reliability Built on Rust

One of the core strengths of Air Pipe is that it is built on Rust, known for its memory safety, thread safety, and high performance. Whether you're managing large-scale databases or smaller applications, Rust ensures your APIs run smoothly and securely.

Why Google Gemini?

Google Gemini AI is a powerful platform for advanced natural language processing and machine learning, ideal for building intelligent, scalable applications. Its real-time capabilities and seamless integration make it a top choice for AI-driven services.

Conclusion

integrating Google Gemini AI with Air Pipe allows developers to build powerful, scalable APIs with ease. By combining Gemini's advanced AI capabilities with Air Pipe's speed, security, and simple deployment, you can create intelligent applications that handle complex tasks efficiently.

Whether you're automating workflows or enhancing data analysis, this seamless integration empowers you to innovate faster. Start building your API today and unlock new possibilities with Air Pipe and Google Gemini AI.

Ready to get started? Head over to Air Pipe and build your first Gemini API in minutes.

Why Air Pipe?

Air Pipe revolutionizes API development, offering a platform where building, deploying, and managing APIs, integrations and workflows takes mere seconds.

Here's why Air Pipe is a game changer:

• Instant Deployment: Get your MongoDB APIs running in 30 seconds flat.

• Secure & Scalable: Built on Rust for memory and thread safety, ensuring your APIs are secure, fast, and scalable.

• Flexible Integration: Effortlessly integrate with databases like MongoDB and more, connect to HTTP endpoints, and run scripts or commands.

• Deploy Anywhere: Use Air Pipe's cloud platform or deploy it self-hosted on any infrastructure.

Step-by-Step Guide to Building MongoDB APIs

This tutorial will focus on the cloud platform deployment but will also work seamlessly for self hosted deployments, you can learn how to self host here → https://docs.airpipe.io/docs/tutorial/setup .

Prerequisites:

• Sign up or log in to Air Pipe.

• MongoDB database or if you don’t have a MongoDB instance register for MongoDB Atlas, create a free cluster and load the sample dataset.

  We’ll be using the MongoDB sample dataset in this tutorial.

Step 1: Create your Configuration

Once signed in to your Air Pipe account, head to Configurations > Add New.

Step 2: Define your MongoDB Data Source

Defining your data source is as simple as naming your database, setting a driver and adding a connection string.

For production deployments we understand your connection string is sensitive, we provide encrypted variable (secret) support https://docs.airpipe.io/docs/configuration/managed-variables .

Other secret stores are also supported.

In the YAML editor paste the below example and update the connection string.

name: mongodb-find-example
description: my mongo api

global:
  databases:
    main: 
      driver: mongodb
      conn_string: |
        mongodb+srv://someUser:somePass@bob-perf.hello.mongodb.net/?retryWrites=true&w=majority&appName=my-test

The global block defines the databases, variables, secrets and templates to be used across API interfaces and its subsequent actions.

Step 3: Creating HTTP interfaces

It’s trivial to create a HTTP interface with Air Pipe, below we set a route name as mongodb/find, the method as POST and output to http.

name: mongodb-find-example
description: my mongo api

global:
  databases:
    main: 
      driver: mongodb
      conn_string: |
        mongodb+srv://someUser:somePass@bob-perf.hello.mongodb.net/?retryWrites=true&w=majority&appName=my-test

interfaces:
  mongodb/find: # this will be used as our route name
    method: POST # method set to POST so we can accept input data
    output: http # output set to HTTP

The same concept can be used for creating webhooks and creating an entry point to any of your configurations that access databases, commands, scripts and other HTTP endpoints.

Step 4: Define your Actions

Actions are a set of instructions an interface will run when called.

1. Select your database to connect to i.e. main

2. Set the document operation and filter.

We’ll also add a mongodb/update interface while we’re at it.

name: mongodb-operations
description: use any mongodb operation

global:
  databases:
    main: 
      driver: mongodb
      conn_string: |
        mongodb+srv://someUser:somePass@bob-perf.hello.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0

interfaces:
  mongodb/find:
    method: POST
    output: http

    actions:
      - name: MongoQuery
        database: main
        document_operation:
          database: sample_analytics 
          collection: customers
          operation: findOne
          filter: '{"name": "a|body::name|"}'

  mongodb/update:
    method: POST
    output: http

    actions:
      - name: MongoQuery
        database: main
        document_operation:
          database: sample_analytics
          collection: customers
          operation: updateOne
          filter: '{"name": "a|body::name|"}'
          update: '{"$set": {"active": a|body::status|}}'

For all available operations and settings view https://docs.airpipe.io/docs/configuration/interfaces/actions/inputs/databases#document_operation

Step 5: Deploy and Test

• Set your permission as USER_WITH_PUBLIC_READ

• Select Deploy to Staging and Deploy to Production and hit create.

It’s that easy your API is live and ready to be consumed in seconds.

Use your favorite API testing tool, or do a curl to your endpoints, let’s try the mongodb/find route, make sure you update your organization uuid in the route.

You can find your organization uuid under Configurations or in your Organization Settings.

• Send a HTTP POST with a JSON payload eg. {"name": "Elizabeth Ray"} to mongodb/find to find a document with a matching name.

• Send a HTTP POST with a JSON payload eg. {"name": "Elizabeth Ray", "status": false} to mongodb/update to find a document with a matching name and update the status value accordingly.

https://api.airpipe.io/YOUR-ORGANIZATION-UUID/production/mongodb/find

curl --location 'https://api.airpipe.io/YOUR-ORGANIZATION-UUID/production/mongodb/find' \
--header 'Content-Type: application/json' \
--data '{
    "name": "Elizabeth Ray",
    "status": true
}'

Example response:

{
    "data": {
        "MongoQuery": {
            "time.ms": 3,
            "data": {
                "_id": {
                    "$oid": "5ca4bbcea2dd94ee58162a68"
                },
                "username": "fmiller",
                "name": "Elizabeth Ray",
                "address": "9286 Bethany Glens\nVasqueztown, CO 22939",
                "birthdate": {
                    "$date": {
                        "$numberLong": "226117231000"
                    }
                },
                "email": "arroyocolton@gmail.com",
                "active": true,
                "accounts": [
                    371138,
                    324287,
                    276528,
                    332179,
                    422649,
                    387979
                ],
                "tier_and_details": {
                    "0df078f33aa74a2e9696e0520c1a828a": {
                        "tier": "Bronze",
                        "id": "0df078f33aa74a2e9696e0520c1a828a",
                        "active": true,
                        "benefits": [
                            "sports tickets"
                        ]
                    },
                    "699456451cc24f028d2aa99d7534c219": {
                        "tier": "Bronze",
                        "benefits": [
                            "24 hour dedicated line",
                            "concierge services"
                        ],
                        "active": true,
                        "id": "699456451cc24f028d2aa99d7534c219"
                    }
                }
            }
        }
    }
}

You’re done! Whats Next?

Air Pipe provides you a fast, consistent and robust development experience that you can continue extending with confidence across anything you build.

You can further add testing, and schema validation for your payloads to suit your requirements or fetch additional data if required.

See:

• Validating Data

• MongoDB Examples

• NoSQL Tutorial

Performance and Reliability Built on Rust

One of the core strengths of Air Pipe is that it is built on Rust, known for its memory safety, thread safety, and high performance. Whether you're managing large-scale databases or smaller applications, Rust ensures your APIs run smoothly and securely.

Why MongoDB?

MongoDB is a popular choice for developers due to its flexibility, scalability, and ease of use. Whether you're building a startup or an enterprise-grade application, MongoDB allows you to store and retrieve your data seamlessly. Coupled with Air Pipe's rapid deployment capabilities, it becomes easier than ever to launch and manage data-driven applications.

Conclusion

Building MongoDB APIs doesn't have to be a daunting task. With Air Pipe, you can achieve in 30 seconds what traditionally takes hours or even days. The combination of performance, security, and flexibility makes Air Pipe an ideal solution for developers and businesses seeking to streamline their workflows and get to market faster.

Ready to get started? Head over to Air Pipe and build your first MongoDB API in just 30 seconds!