Quickstart

This guide walks through the full deployment loop: write a Dockerfile, configure the app, push, and get a live URL. The whole thing takes about 5 minutes.

Prerequisites

• 1ctl installed — see Installation
• A Satusky account and API token — see Authentication
• No Docker, no kubectl, nothing else

Step 1: Authenticate

1ctl auth login --token sat_xxxxxxxxxxxxxxxxxxxxxxxx

Expected output:

Authenticated as [email protected] (org: my-org)
Context saved to ~/.satusky/context.json

Step 2: Create a project

Make a directory and add a simple application. Here’s a minimal Go HTTP server:

mkdir my-app && cd my-app

main.go:

package main

import (
    "fmt"
    "net/http"
    "os"
)

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello from Satusky")
    })

    http.ListenAndServe(":"+port, nil)
}

Dockerfile:

FROM golang:1.24-alpine AS build
WORKDIR /app
COPY . .
RUN go build -o server .

FROM alpine:3.19
WORKDIR /app
COPY --from=build /app/server .
EXPOSE 8080
CMD ["./server"]

Step 3: Initialize the project

1ctl init

1ctl init asks a few questions — project name, namespace, resource limits — then writes satusky.toml to the project root.

Expected output:

? Project name: my-app
? Namespace: production
? CPU limit [0.5]: 0.5
? Memory limit [256Mi]: 256Mi
? Port [8080]: 8080

Created satusky.toml

The generated satusky.toml looks like this:

[app]
name       = "my-app"
namespace  = "production"

[build]
dockerfile = "Dockerfile"

[resources]
cpu    = "0.5"
memory = "256Mi"

[network]
port = 8080

You can edit this file directly before deploying. See the configuration reference for all available fields.

Step 4: Deploy

1ctl deploy

Expected output:

Building image...
  Uploading source context   [================] 100%
  Step 1/6: FROM golang:1.24-alpine AS build
  Step 2/6: WORKDIR /app
  Step 3/6: COPY . .
  Step 4/6: RUN go build -o server .
  Step 5/6: FROM alpine:3.19
  Step 6/6: COPY --from=build /app/server .
  Image built and pushed: registry.satusky.com/my-org/my-app:a3f8c21

Deploying...
  Deployment created: my-app
  Waiting for rollout...  [====] ready (2s)

  URL: https://my-app.my-org.satusky.app

Your app is live at the printed URL.

Step 5: Check deployment status

1ctl deploy status

Expected output:

Deployment: my-app
Namespace:  production
Status:     running
Replicas:   1/1 ready
Image:      registry.satusky.com/my-org/my-app:a3f8c21
CPU:        0.5
Memory:     256Mi
URL:        https://my-app.my-org.satusky.app
Created:    2026-04-27T10:00:00Z

Step 6: View logs

1ctl logs

Stream live logs from the running container:

2026-04-27T10:00:05Z [my-app] server listening on :8080
2026-04-27T10:00:12Z [my-app] GET / 200 142µs

Pass -f to follow (tail -f style) or --since 1h to limit the time window.

What just happened

1. Cloud build — 1ctl deploy uploaded your project source to Satusky’s build service. Kaniko built the Docker image inside the cluster. No local Docker daemon was involved.

2. Image push — The built image was pushed to Satusky’s internal registry (registry.satusky.com).

3. Kubernetes deployment — Satusky created a Kubernetes Deployment in the production namespace with the resource limits from satusky.toml. A service and public route were created automatically.

4. Public route and TLS — Satusky provisioned a subdomain (my-app.my-org.satusky.app) and a TLS certificate. HTTPS is on by default.

Next steps

• Authentication — manage API tokens and profiles for multiple environments
• Environment variables — set runtime config and secrets
• Custom domains — attach your own domain
• CI/CD — automate deploys from GitHub Actions or any CI system