Shipping to the cloud shouldn’t be a maze of YAML, clusters, and hand-rolled pipelines. Cloud Launchpad is a cloud automation stack that provisions what you need on AWS and automates the path from source (or container) to a running, monitored application on Amazon EKS (Elastic Kubernetes Service)—with sensible defaults and zero guesswork.

What Cloud Launchpad Does

• Provisions infrastructure: Creates an EKS cluster, manages node groups on Amazon EC2, and configures an external load balancer and DNS endpoint.
• Builds and ships your app: Either from your GitHub repository or from images you’ve already pushed to Amazon ECR (Elastic Container Registry).
• Sets up CI/CD for you: Pipelines (powered by Jenkins under the hood) compile, containerize, and deploy to Kubernetes.
• Adds common building blocks: One-click setup for databases (Amazon RDS), caching (Redis), and queues (RabbitMQ or Apache Kafka).
• Observability built in: Health checks and live logs in the UI.
• Safe, repeatable releases: Rolling updates on Kubernetes Pods for zero-downtime redeploys.
  

Two Ways to Deploy

You can choose the flow that fits your team’s needs—without changing how you build software.

1) GitHub → Build → ECR → EKS (fully automated)

Best when you’re comfortable sharing repository access.

1. Create a project
   
   • Enter a project name and your AWS credentials (validated server-side).
   • Pick an AWS Region, node group parameters, and an EKS cluster name.
     
2. Connect GitHub
   
   • Provide a GitHub token, repo owner, and select your repository.
   • Choose a branch and indicate whether your app is monolithic or microservices (select one or many services).
     
3. Build settings
   
   • Set the technology/runtime (e.g., Node/React version).
   • Provide an ECR repository name, container name, container port, and an optional health-check endpoint.
     
4. Launch
   
   • Cloud Launchpad builds a Docker image, pushes to ECR, creates/updates the EKS cluster and node groups, deploys workloads, and wires up the load balancer.
   • You’ll get a DNS endpoint to drop into your environment configuration.

Typical first-time provisioning and deployment completes in ~20–30 minutes, depending on project size and AWS capacity.

2) Prebuilt Container (ECR) → EKS (code never leaves your control)

Best when you don’t want to share code or you already produce images in your own pipeline.

1. Create a project (same as above): AWS credentials, Region, node group, cluster name.
   
2. Register services
   
   • For each microservice, select the ECR repository, image name, and tag (e.g., latest or a semver tag).
   • Specify container name, container port, and optional health-check endpoint.
     
3. Launch
   
   • Cloud Launchpad deploys the images to your cluster and exposes a DNS endpoint.
     

After Deployment

• DNS you can use immediately
  Copy the provided DNS name into your frontend or backend environment file and you’re live.
  
• Add services anytime
  Already shipping and need a new microservice? Add it from Additional Microservices—no need to re-provision the whole project.
  
• Built-in add-ons
  
  • Database: Provision Amazon RDS and connect via config/env.
  • Caching: Enable Redis, get credentials and port, and plug it into your app.
  • Queues: Add RabbitMQ or Kafka for async workloads.
    
• Redeploys without downtime
  Click Redeploy, point to a new image tag (ECR flow) or latest code (GitHub flow). Cloud Launchpad performs a rolling update—new Pods come up healthy before old ones are drained. The URL stays the same.
  
• Monitoring & logs
  View live logs per service in the Monitoring view to spot errors and verify health checks.
  
• User management
  Create and manage user accounts with appropriate access to projects.

What’s Happening Behind the Scenes

• Infrastructure: EKS cluster and EC2 node groups are provisioned; a Kubernetes-compatible load balancer is configured for ingress.
• Containers: Images live in Amazon ECR.
• Pipelines: Jenkins orchestrates builds and deployments programmatically (kept out of the UI to avoid manual misconfigurations).
• Kubernetes: Deployments use rolling updates; Pods are replaced incrementally to keep the service available.

When to Use Which Flow

• GitHub Flow: You want end-to-end automation from source to production with minimal setup.
  
• ECR Flow: You’re privacy-sensitive about code, or you already have a container build pipeline and just want reliable Kubernetes deployments.
  

Quick Start Checklist

1. Have ready: AWS account & credentials, target Region, desired cluster name, and either a GitHub repo or ECR images/tags.
   
2. Create a project in Cloud Launchpad and pick a deployment flow.
   
3. Configure services (ports, health checks, runtime versions).
   
4. Launch and wait for the DNS endpoint.
   
5. Plug DNS into your app’s config and verify via the Monitoring view.
   
6. Iterate: Use Redeploy for new versions; add databases, caching, and queues as needed.

Why Teams Choose Cloud Launchpad

• Fewer handoffs between developers and DevOps
• Consistent, auditable releases across environments
• Kubernetes without the pain—best practices baked in
• Scale-ready: start small, grow into microservices and add-ons at your pace

If you’d like help mapping your existing repos or containers to Cloud Launchpad—or want suggestions on cluster sizing and add-ons for your workload—reach out and we’ll walk through a tailored setup.