SEAGIT DOCS
Getting Started Guide

Getting Started Guide

Deploy your first application on SeaGit in 30 minutes. This step-by-step tutorial will take you from signup to a running, production-ready application with custom domain and TLS.

What You'll Build

Infrastructure:

  • ✓ AWS VPC with public/private subnets
  • ✓ Production EKS cluster (2 nodes)
  • ✓ ALB ingress controller
  • ✓ Automatic TLS certificates
  • ✓ DNS management

Application:

  • ✓ Node.js app from GitHub
  • ✓ Automatic buildpack detection
  • ✓ Custom domain (api.yourdomain.com)
  • ✓ HTTPS with Let's Encrypt
  • ✓ Auto-scaling (2-5 replicas)

Estimated Time: 30 minutes

(Including 15-20 minutes for EKS cluster creation)

Prerequisites

Before starting, ensure you have:

  • AWS Account: Active account with admin access
  • Domain Name: Optional, but recommended for full experience (can use seagit-provided subdomain)
  • GitHub Account: For source code repository (or use Docker image)
  • Credit Card: For AWS resources (est. $50-100/month for this setup)

Cost Estimate:

This tutorial will create AWS resources that incur costs. Estimated monthly cost: $70-100 (EKS control plane: $73, t3.medium nodes: $30, ALB: $16, data transfer: varies). Clean up resources after tutorial to avoid charges.

Step 1: Sign Up for SeaGit

1.1 Create Account

  1. 1. Navigate to https://seagit.com
  2. 2. Click Sign Up in the top right
  3. 3. Enter your email address and create a strong password
  4. 4. Accept terms of service
  5. 5. Click Create Account

1.2 Verify Email

Check your email for verification link. Click to verify your account.

1.3 Create Organization (Optional)

After verification, you can use the SeaGit "main" organization without the need to create a new organization, or you can create one if desired. If you choose to create an organization, you'll be prompted to enter the following:

  • Organization Name: MyCompany

✓ Step 1 Complete

You should now be able to manage organizations from the SeaGit dashboard.

Step 2: Add AWS Provider

Connect your AWS account so SeaGit can provision infrastructure.

2.1 Create IAM User in AWS

  1. 1. Log into AWS IAM Console
  2. 2. Go to Users → Add User
  3. 3. User name: seagit-automation
  4. 4. Select Programmatic access
  5. 5. Click Next: Permissions

2.2 Attach IAM Policies

Attach these AWS managed policies:

  • ☑ AmazonEC2FullAccess
  • ☑ AmazonEKSClusterPolicy
  • ☑ AmazonEKSWorkerNodePolicy
  • ☑ AmazonVPCFullAccess
  • ☑ AmazonRoute53FullAccess
  • ☑ ElasticLoadBalancingFullAccess

Security Note: In production, use more restrictive custom policies. These broad policies are for tutorial simplicity.

2.3 Generate Access Keys

  1. 1. Complete user creation wizard
  2. 2. On final screen, download credentials CSV or copy access key ID and secret
  3. 3. Store these securely (you won't be able to view secret again)

2.4 Add Provider in SeaGit

  1. 1. In SeaGit, navigate to Providers
  2. 2. Click Add Provider
  3. 3. Select AWS
  4. 4. Fill in details:
    • Name: AWS Production
    • Access Key ID: (paste from CSV)
    • Secret Access Key: (paste from CSV)
    • Default Region (if prompted): us-east-1
  5. 5. Click Save

✓ Step 2 Complete

AWS provider connected and ready.

Step 3: Create VPC Network

Create a virtual private cloud for your infrastructure.

3.1 Navigate to Networks

In left sidebar, click Networks → Create Network

3.2 Configure VPC

  • Name: production-vpc
  • Provider: AWS Production
  • Region: us-east-1
  • CIDR Block: 10.0.0.0/16 (65,536 IPs)
  • Availability Zones: 2 (us-east-1a, us-east-1b)
  • Public Subnets: Yes (for load balancers)
  • Private Subnets: Yes (for applications)
  • NAT Gateway: Yes (1 per AZ for high availability)

3.3 Create Network

Click Create. This takes 3-5 minutes.

SeaGit will create: VPC, subnets, internet gateway, NAT gateways, route tables, and security groups.

✓ Step 3 Complete

VPC created and ready for cluster.

Step 4: Create EKS Cluster

⏱️ Note: This step takes 15-20 minutes. Perfect time for a coffee break!

4.1 Navigate to Clusters

Click Clusters → Create Cluster

4.2 Basic Configuration

  • Name: production-cluster
  • Provider: AWS Production
  • Network: production-vpc
  • Kubernetes Version: 1.32 (latest stable)

4.3 Configure Node Group

Default Node Group: On-Demand

  • Instance Type: t3.medium (2 vCPU, 4 GB RAM - AMD64)
  • Min Nodes: 2
  • Max Nodes: 5
  • Disk Size: 20 GB

Default Node Group: Spot (Expand this section if you need to have spot instances)

  • Instance Type: t4g.medium (2 vCPU, 4 GB RAM - ARM64)
  • Min Nodes: 0
  • Max Nodes: 2

✓ Note: We support bottlerocket so the instance type here is just an example if you need to have a mix of architectures between AMD64 and ARM64

4.4 Install Add-ons

Select these add-ons for automatic installation:

  • ☑ ALB Controller - AWS Load Balancer integration
  • ☑ Cert-Manager - Automatic TLS certificates
  • ☑ External DNS - Automatic DNS record creation
  • ☑ Metrics Server - Resource metrics for autoscaling
  • ☐ Prometheus - Optional (adds monitoring)
  • ☐ ArgoCD - Optional (adds GitOps)

4.5 Create Cluster

  1. 1. Review configuration
  2. 2. Click Create Cluster
  3. 3. Monitor progress in real-time
  4. 4. Wait for status to show Ready

What's happening? SeaGit is creating EKS control plane, launching EC2 instances, configuring networking, installing add-ons, and verifying everything is healthy.

✓ Step 4 Complete

Kubernetes cluster running and ready for applications.

Step 5: Create Production Environment

Environments group clusters and define DNS/ingress configuration.

5.1 Navigate to Environments

Click Environments → Create Environment

5.2 Configure Environment

  • Name: production
  • Description: Production environment
  • Root Domain: yourdomain.com (or use seagit subdomain)
  • Ingress Class: alb (AWS Load Balancer)
  • TLS: Enabled (auto-issue certificates)

5.3 Attach Cluster

Select production-cluster to attach it to this environment.

5.4 DNS Configuration (Optional)

If using custom domain:

  1. 1. Add your DNS provider (Cloudflare, Route53, PowerDNS)
  2. 2. SeaGit will automatically create DNS records for deployments
  3. 3. Or manually create CNAME to ALB endpoint (shown after first deployment)

✓ Step 5 Complete

Environment configured and ready for applications.

Step 6: Add Application

Create an application template that can be deployed to any environment.

6.1 Navigate to Applications

Click Applications → Create Application

6.2 Basic Information

  • Name: api-service
  • Description: Backend API service

6.3 Source Configuration

Choose your source type:

Option A: Container Image (Recommended for tutorial)

  • Source Type: Container
  • Image: nginx:latest (or your image)
  • Registry: Docker Hub (or private registry)

Option B: GitHub (This needs to be connected to your GitHub account, follow this guide)

  • Source Type: Git
  • Provider: GitHub
  • Repository: your-username/your-repo
  • Branch: main
  • Build Type: Buildpack (auto-detect)

6.4 Resource Configuration

  • CPU Request: 0.25 vCPU
  • CPU Limit: 0.5 vCPU
  • Memory Request: 256 MB
  • Memory Limit: 512 MB
  • Min Replicas: 2
  • Max Replicas: 5
  • Autoscaling: Enabled (CPU > 70%)

6.5 Network Configuration

  • Container Port: 3000 (or your app's port)
  • Protocol: HTTP
  • Health Check Path: /health or /
  • Service Type: ClusterIP
  • Public Exposure: Yes (via ingress)

6.6 Environment Variables (Optional)

Add any environment variables your app needs:

NODE_ENV=production
LOG_LEVEL=info
PORT=3000

6.7 Save Application Template

Click Create Application. Template saved and ready to instantiate.

✓ Step 6 Complete

Application template created.

Step 7: Create Application Instance

Instantiate the template for the production environment.

7.1 Create Instance

  1. 1. From application page, click Create Instance
  2. 2. Select production environment
  3. 3. Instance name: api-service-prod (auto-generated)
  4. 4. Customize instance settings as needed
  5. 5. Click Deploy

✓ Step 7 Complete

Instance created with a main deployment.

Step 8: Deploy More Silos (Skip this section if not needed)

If you want to experiment and deploy more silos of your instance by changing some variables or settings, follow these steps:

8.1 Start Deployment

  1. 1. From the instance page, click New Deploy
  2. 2. Select target cluster: production-cluster
  3. 3. Version: main (or specific commit/tag)
  4. 4. Click Deploy

8.2 Monitor Deployment

Watch real-time progress through these phases:

  • ●
    Queued - Deployment request received

    Usually instant

  • ●
    Starting - Build - Building from source code

    1-3 minutes (if using Git source)

  • ●
    Starting - Deploy - Creating Kubernetes resources

    30 seconds

  • ●
    Starting - Health Check - Waiting for pods to be ready

    30-60 seconds

  • ●
    Started - Deployment successful!

    Application is now running

    • 8.3 View Logs

    Click Logs tab to see real-time container output.

    ✓ Step 8 Complete

    Application deployed and running!

    Step 9: Verify & Access

    Test your deployed application.

    9.1 Get Access URL

    In the deployment details, find your application URL:

    https://api.yourdomain.com

    If using custom domain and DNS isn't configured yet, use the preview URL or ALB endpoint shown in deployment details.

    9.2 Test Application

    # Using curl
curl https://api.yourdomain.com

# Or open in browser
open https://api.yourdomain.com

    9.3 Verify TLS Certificate

    Check that HTTPS is working with a valid Let's Encrypt certificate:

    • • Browser shows green padlock icon
    • • Certificate issued by Let's Encrypt
    • • Valid for 90 days (auto-renews)

    9.4 Check Auto-Scaling

    Generate load to test horizontal pod autoscaling:

    # Install hey load testing tool (macOS)
brew install hey

# Generate load
hey -z 60s -c 100 https://api.yourdomain.com

# Watch pods scale in SeaGit dashboard
# Should scale from 2 to 3-5 replicas under load

    ✓ Step 9 Complete

    Application verified and accessible!

    Step 10: Set Up Cost Optimization (Optional)

    Save money with automated resource management.

    10.1 Create Action Rule

    For non-production environments, automate stop/start:

    1. 1. Navigate to Organization Settings → Action Rules
    2. 2. Click Create Action Rule
    3. 3. Configure:
      • Name: Stop Dev After Hours
      • Filter: dev-.*
      • Resource Types: Clusters, Applications
      • Schedule: Mon-Fri 6:00 PM
      • Action: Stop
    4. 4. Create matching rule to start at 8 AM

    10.2 Estimated Savings

    Cost Savings Calculator:

    Production (24/7):       $100/month
Dev with automation:     $40/month (60% savings)

Annual savings per dev cluster: $720

    ✓ Step 10 Complete

    Automation configured for cost optimization!

    🎉 Congratulations!

    You've successfully deployed your first application on SeaGit!

    What You've Accomplished:

    • ✓ Created AWS VPC with proper networking
    • ✓ Deployed production-ready Kubernetes cluster
    • ✓ Configured automatic TLS certificates
    • ✓ Set up DNS routing
    • ✓ Deployed application from source code
    • ✓ Enabled auto-scaling
    • ✓ Configured cost optimization
    • ✓ Achieved production-ready setup

    Next Steps

    Add Staging Environment

    Create a separate environment for testing before production deployments.

    Advanced Automation

    Set up CI/CD pipelines, automated testing, and scheduled deployments.

    Manage Secrets

    Add database credentials, API keys, and other sensitive configuration.

    Multi-Region Setup

    Deploy to multiple regions for high availability and global performance.

    Need Help?

    Previous: AutomationNext: Troubleshooting Guide