feat: set container hostname equal to container name

feat(smm): Add OpenGraph tags

.dockerignore

@@ -0,0 +1,11 @@
+# Ignore everything and use an allowlist of what is allowed to not package any secrets by accident.
+*
+
+# Allow files and directories.
+!cmd/
+!internal/
+!scripts/docker/
+!go.*
+
+# Ignore unnecessary files inside allowed directories.
+**/.DS_Store

.gitignore

@@ -8,6 +8,9 @@
 *.so
 *.dylib
 
+# OS X
+.DS_Store
+
 # Test binary, built with `go test -c`
 *.test
 
@@ -26,3 +29,9 @@ go.work.sum
 
 data
 dist/
+
+# Web
+node_modules/
+
+# VS Code
+.vscode

.goreleaser.yaml

@@ -40,23 +40,27 @@ archives:
   - id: uncloud
     builds:
       - uncloud
-    format: gz
+    formats:
+      # gz is not compatible with homebrew releases, so we use tar.gz
+      - tar.gz
     name_template: >-
       {{ .Binary }}_
       {{- if eq .Os "darwin"}}macos
       {{- else}}{{.Os}}{{end}}_
-      {{- .Arch }}"
+      {{- .Arch }}
     # use zip for windows archives
     format_overrides:
       - goos: windows
-        format: zip
+        formats:
+          - zip
     files:
       - none*
 
   - id: uncloudd
     builds:
       - uncloudd
-    format: gz
+    formats:
+      - tar.gz
     name_template: "{{ .Binary }}_{{ .Os }}_{{ .Arch }}"
     files:
       - none*
@@ -70,3 +74,18 @@ changelog:
     exclude:
       - "^docs:"
       - "^test:"
+
+brews:
+  - name: uncloud
+    description: "Uncloud CLI"
+    homepage: "https://uncloud.run"
+    ids:
+      - uncloud
+    install: |
+      bin.install "uncloud"
+      bin.install_symlink "uncloud" => "uc"
+    skip_upload: false
+    repository:
+      owner: psviderski
+      name: homebrew-tap
+      token: "{{ .Env.GITHUB_TOKEN_HOMEBREW_TAP }}"

.mise.toml

@@ -1,5 +1,5 @@
 [tools]
-go = "1.22"
+go = "1.23"
 
 [env]
 _.file = ".env"

Dockerfile

@@ -0,0 +1,51 @@
+ARG ALPINE_VERSION=3.20.3
+
+FROM golang:1.23.2-alpine AS uncloudd
+
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV CGO_ENABLED=0
+
+WORKDIR /build
+# Download and cache dependencies and only redownload them in subsequent builds if they change.
+COPY go.mod go.sum ./
+RUN go mod download && go mod verify
+
+COPY . .
+RUN GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o uncloudd cmd/uncloudd/main.go
+
+
+FROM alpine:${ALPINE_VERSION} AS corrosion-download
+RUN wget -q -O /tmp/corrosion.tar.gz \
+      https://github.com/psviderski/corrosion/releases/latest/download/corrosion-aarch64-unknown-linux-gnu.tar.gz \
+    && tar -xzf /tmp/corrosion.tar.gz -C /tmp \
+    && install /tmp/corrosion /usr/local/bin/corrosion \
+    && rm /tmp/corrosion.tar.gz /tmp/corrosion
+
+FROM chainguard/wolfi-base:latest AS corrosion
+COPY --from=corrosion-download /usr/local/bin/corrosion /usr/local/bin/corrosion
+CMD ["corrosion", "agent"]
+
+
+FROM alpine:${ALPINE_VERSION} AS corrosion-image-tarball
+ARG CORROSION_IMAGE="ghcr.io/psviderski/corrosion:latest"
+
+RUN apk --no-cache add crane
+RUN crane pull "${CORROSION_IMAGE}" /corrosion.tar
+
+
+# Uncloud-in-Docker (ucind) image for running Uncloud test clusters using Docker.
+FROM docker:27.3.1-dind AS ucind
+# Create system group and user 'uncloud'.
+RUN addgroup -S uncloud && adduser -SHD -h /nonexistent -G uncloud -g "" uncloud
+RUN apk --no-cache add \
+    socat \
+    wireguard-tools
+
+COPY --from=corrosion-image-tarball /corrosion.tar /images/corrosion.tar
+COPY scripts/docker/dind scripts/docker/entrypoint.sh /usr/local/bin/
+COPY --from=uncloudd /build/uncloudd /usr/local/bin/
+
+ENTRYPOINT ["entrypoint.sh"]
+CMD ["uncloudd"]

Makefile

@@ -1,16 +1,52 @@
-.PHONY: build
-uncloud-dev:
+CORROSION_IMAGE ?= ghcr.io/psviderski/corrosion:latest
+UCIND_IMAGE ?= ghcr.io/psviderski/ucind:latest
+
+update-dev:
 	GOOS=linux GOARCH=amd64 go build -o uncloudd-linux-amd64 ./cmd/uncloudd && \
 		scp uncloudd-linux-amd64 spy@192.168.40.243:~/ && \
 		ssh spy@192.168.40.243 sudo install ./uncloudd-linux-amd64 /usr/local/bin/uncloudd
 		scp uncloudd-linux-amd64 spy@192.168.40.176:~/ && \
-		ssh spy@192.168.40.176 sudo install ./uncloudd-linux-amd64 /usr/local/bin/uncloudd
-	GOOS=linux GOARCH=amd64 go build -o uncloud-linux-amd64 ./cmd/uncloud && \
-		scp uncloud-linux-amd64 spy@192.168.40.243:~/ && \
-		ssh spy@192.168.40.243 sudo install ./uncloud-linux-amd64 /usr/local/bin/uncloud
-		scp uncloud-linux-amd64 spy@192.168.40.176:~/ && \
-		ssh spy@192.168.40.176 sudo install ./uncloud-linux-amd64 /usr/local/bin/uncloud
+		ssh spy@192.168.40.176 sudo install ./uncloudd-linux-amd64 /usr/local/bin/uncloudd && \
+		rm uncloudd-linux-amd64
+#	GOOS=linux GOARCH=arm64 go build -o uncloudd-linux-arm64 ./cmd/uncloudd && \
+#		scp uncloudd-linux-arm64 ubuntu@152.67.101.197:~/ && \
+#		ssh ubuntu@152.67.101.197 sudo install ./uncloudd-linux-arm64 /usr/local/bin/uncloudd && \
+#		rm uncloudd-linux-arm64
+
+update-restart-dev:
+	GOOS=linux GOARCH=amd64 go build -o uncloudd-linux-amd64 ./cmd/uncloudd && \
+		scp uncloudd-linux-amd64 spy@192.168.40.243:~/ && \
+		ssh spy@192.168.40.243 "sudo install ./uncloudd-linux-amd64 /usr/local/bin/uncloudd && sudo systemctl restart uncloud" && \
+		scp uncloudd-linux-amd64 spy@192.168.40.176:~/ && \
+		ssh spy@192.168.40.176 "sudo install ./uncloudd-linux-amd64 /usr/local/bin/uncloudd && sudo systemctl restart uncloud" && \
+		rm uncloudd-linux-amd64
+#	GOOS=linux GOARCH=arm64 go build -o uncloudd-linux-arm64 ./cmd/uncloudd && \
+#		scp uncloudd-linux-arm64 ubuntu@152.67.101.197:~/ && \
+#		ssh ubuntu@152.67.101.197 "sudo install ./uncloudd-linux-arm64 /usr/local/bin/uncloudd && sudo systemctl restart uncloud" && \
+#		rm uncloudd-linux-arm64
+
+reset-dev:
+	ssh spy@192.168.40.243 "sudo systemctl stop uncloud && sudo rm -rf /var/lib/uncloud"
+	ssh spy@192.168.40.176 "sudo systemctl stop uncloud && sudo rm -rf /var/lib/uncloud"
+	ssh ubuntu@152.67.101.197 "sudo systemctl stop uncloud && sudo rm -rf /var/lib/uncloud"
 
 .PHONY: proto
 proto:
-	protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative internal/machine/api/pb/*.proto
+	protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative \
+		--proto_path=. --proto_path=internal/machine/api/vendor internal/machine/api/pb/*.proto
+
+.PHONY: corrosion-image
+corrosion-image:
+	docker build -t "$(CORROSION_IMAGE)" --target corrosion .
+
+.PHONY: corrosion-image-push
+corrosion-image-push: corrosion-image
+	docker push "$(CORROSION_IMAGE)"
+
+.PHONY: ucind-image
+ucind-image:
+	docker build -t "$(UCIND_IMAGE)" --target ucind .
+
+.PHONY: ucind-image-push
+ucind-image-push: ucind-image
+	docker push "$(UCIND_IMAGE)"

README.md

@@ -1,9 +1,185 @@
-# Uncloud
+<div align="center">
+  <img src="./website/images/logo.svg" height="100" alt="Uncloud logo"/>
+  <h1>Uncloud</h1>
+  <p><strong>Docker simplicity. Multi-machine power.</strong></p>
+</div>
 
-Uncloud is a lightweight tool for deploying and managing containerised applications across a network of Docker hosts. It
-bridges the gap between simple Docker deployments and complex cloud platforms and container orchestrators like
-Kubernetes.
+Uncloud is a lightweight clustering and container orchestration tool that lets you deploy and manage web apps across
+cloud VMs and bare metal with minimized cluster management overhead. It creates a secure WireGuard mesh network between
+your Docker hosts and provides automatic service discovery, load balancing, ingress with HTTPS, and simple CLI commands
+to manage your apps.
 
-Our goal is to become the go-to self-hosted alternative to platforms like [Fly.io](https://fly.io) and
-[Render](https://render.com/). Whether you're using bare metal servers, Raspberry Pis, or cloud VMs, Uncloud transforms
-your hardware into a personal cloud platform.
+Unlike traditional orchestrators, there's no central control plane and quorum to maintain. Each machine maintains a
+synchronized copy of the cluster state through peer-to-peer communication, keeping cluster operations functional even if
+some machines go offline.
+
+Uncloud aims to be the solution for developers who want the flexibility of self-hosted infrastructure without the
+operational complexity of Kubernetes.
+
+## ✨ Features
+
+* **Deploy anywhere**: Combine cloud VMs, dedicated servers, and bare metal into a unified computing environment —
+  regardless of location or provider.
+* **Zero-config private network**: Automatic WireGuard mesh with peer discovery and NAT traversal. Containers get unique
+  IPs for direct cross-machine communication.
+* **No control plane**: Fully decentralized design eliminates single points of failure and reduces operational overhead.
+* **Imperative over declarative**: Favoring imperative operations over state reconciliation simplifies both the mental
+  model and troubleshooting.
+* **Service discovery**: Built-in DNS server resolves service names to container IPs.
+* **Automatic HTTPS**: Built-in Caddy reverse proxy handles TLS certificate provisioning and renewal using Let's
+  Encrypt.
+* **Docker-like CLI**: Familiar commands for managing both infrastructure and applications.
+* **Remote management**: Control your entire infrastructure through SSH access to any single machine in the cluster.
+
+Coming soon:
+
+* Project isolation through environments/namespaces
+* Infrastructure as Code using Docker Compose format
+* Persistent volumes and secrets management
+* Monitoring and log aggregation
+* Database deployment and management
+* Curated application catalog
+
+Here is a diagram of an Uncloud multi-provider cluster of 3 machines:
+
+![Diagram: multi-provider cluster of 3 machines](website/images/diagram.webp)
+
+## 💫 Why Uncloud?
+
+Modern cloud platforms like Heroku and Render offer amazing developer experiences but at a premium price. Traditional
+container orchestrators like Kubernetes provide power and flexibility but require significant operational expertise. I
+believe there's a sweet spot in between — a pragmatic solution for the majority of us who aren't running at Google
+scale. You should be able to:
+
+* **Own your infrastructure and data**: Whether driven by costs, compliance, or flexibility, run applications on any
+  combination of cloud VMs and personal hardware while maintaining the cloud-like experience you love.
+* **Stay simple**: Don't worry about control planes, highly-available clusters, or complex YAML configurations for
+  common use cases.
+* **Build with proven primitives**: Get production-grade networking, deployment primitives, service discovery, load
+  balancing, and ingress with HTTPS out of the box without becoming a distributed systems expert.
+* **Support sustainable computing** 🌿: Minimize system overhead to maximize resources available for your applications.
+
+Uncloud's goal is to make deployment and management of containerized applications feel as seamless as using a cloud
+platform, whether you're running on a $5 VPS, a spare Mac mini, or a rack of bare metal servers.
+
+## 🚀 Quick start
+
+1. Install Uncloud CLI:
+
+```bash
+brew install psviderski/tap/uncloud
+
+# or using curl (macOS/Linux)
+curl -fsS https://get.uncloud.run/install.sh | sh
+```
+
+2. Initialize your first machine:
+
+```bash
+uc machine init root@your-server-ip
+```
+
+3. Create a DNS A record in your DNS provider (Cloudflare, Namecheap, etc.) that points `app.example.com` to your
+   server's IP address. Allow a few minutes for DNS propagation.
+4. Deploy your app from a Docker image:
+
+```bash
+uc run -p app.example.com:8000/https my-app-image
+```
+
+That's it! Your app is now running and accessible at https://app.example.com ✨
+
+5. Clean up when you're done:
+
+```bash
+uc ls
+# Copy the service ID from the output and remove it:
+uc rm my-app-id
+```
+
+## ⚙️ How it works
+
+Check out the [design document](docs/design.md) to understand Uncloud's design philosophy and goals. Here, let's peek
+under the hood to see what happens when you run certain commands.
+
+**When you initialize a new cluster on a machine:**
+
+```bash
+uc machine init root@your-server-ip
+```
+
+1. The CLI SSHs into the machine and installs Docker, the `uncloudd` machine daemon and
+   [corrosion](https://github.com/superfly/corrosion) service, managed by systemd.
+2. Generates a unique WireGuard key pair, allocates a dedicated subnet `10.210.0.0/24` for the machine and its
+   containers, and configures `uncloudd` accordingly. All subsequent communication happens with `uncloudd`
+   through its gRPC API over SSH.
+3. Configures and starts `corrosion`, a CRDT-based distributed SQLite database to share cluster state between machines.
+4. Creates a Docker bridge network connected to the WireGuard interface.
+5. This machine becomes an entry point for the newly created cluster which is stored in the cluster config under
+   `~/.config/uncloud` on your local machine.
+
+**When you add another machine:**
+
+```bash
+uc machine add ubuntu@second-server-ip
+```
+
+1. The second machine gets provisioned just like the first. A non-root SSH user will need `sudo` access.
+2. Allocates a new subnet `10.210.1.0/24` for the second machine and its containers.
+3. Registers the second machine in the cluster state and exchanges WireGuard keys with the first machine.
+4. Both machines establish a WireGuard tunnel between each other, allowing Docker containers connected to the bridge
+   network to communicate directly across machines.
+5. Configures and starts `corrosion` on the second machine to sync the cluster state.
+6. The second machine is added as an alternative entry point in the cluster config.
+7. If one of the machines goes offline, the other machine can still serve cluster operations.
+
+If one more machine is added, the process repeats with a new subnet. The new machine needs to establish a WireGuard
+connection with only one of the existing machines. Other machines will learn about it through the shared cluster state
+and automatically establish a WireGuard tunnel with it.
+
+**When you run a service:**
+
+```bash
+uc run -p app.example.com:8000/https my-app-image
+```
+
+1. CLI picks a machine to run your container.
+2. `uncloudd` that the CLI communicates with uses [`grpc-proxy`](https://github.com/siderolabs/grpc-proxy) to forward
+   the request to the target machine to launch a container there.
+3. `uncloudd` on the target machine starts the Docker container in the bridge network and stores its info in the
+   cluster's distributed state.
+4. The container gets a cluster-unique IP address from the bridge network (in the `10.210.X.2-254` range) and becomes
+   accessible from other machines in the cluster.
+5. Caddy reverse proxy which runs in [`global`](https://github.com/compose-spec/compose-spec/blob/main/deploy.md#mode)
+   mode on each machine watches the cluster state for new services and updates its configuration to route traffic to the
+   new container.
+
+Look ma, no control plane or master nodes to maintain! Just a simple overlay network and eventually consistent state
+sync that lets machines work together. Want to check on things or make changes? Connect to any machine either implicitly
+using the CLI or directly over SSH. They all have the complete cluster state and can control everything. It's like each
+machine is a full backup of your control plane.
+
+## 🏗 Project status
+
+Uncloud is currently in active development and is **not ready for production use**. Features may change significantly
+and there may be breaking changes between releases.
+
+I'd love your input! Here's how you can contribute:
+
+* 🐛 Found a bug? [Open an issue](https://github.com/psviderski/uncloud/issues)
+* 💡 Have ideas? [Join the discussion](https://github.com/psviderski/uncloud/discussions)
+
+## 📫 Stay updated
+
+* [Subscribe](https://uncloud.run/#subscribe) to my newsletter to follow the progress, get early insights into new
+  features, and be the first to know when it's ready for production use.
+* Watch this repository for releases.
+* Follow [@psviderski](https://github.com/psviderski) on GitHub.
+
+## ❤️ Contributors
+
+Thank you [@cedws](https://github.com/cedws) for being the first contributor to Uncloud! 🎉
+
+<a href="https://github.com/psviderski/uncloud/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=psviderski/uncloud" />
+</a>

cmd/ucind/cluster/create.go

@@ -0,0 +1,34 @@
+package cluster
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"uncloud/internal/ucind"
+)
+
+func NewCreateCommand() *cobra.Command {
+	opts := ucind.CreateClusterOptions{}
+	cmd := &cobra.Command{
+		Use:   "create [NAME]",
+		Short: "Create a new cluster.",
+		Args:  cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			p := cmd.Context().Value("provisioner").(*ucind.Provisioner)
+
+			name := DefaultClusterName
+			if len(args) > 0 {
+				name = args[0]
+			}
+
+			if _, err := p.CreateCluster(cmd.Context(), name, opts); err != nil {
+				return fmt.Errorf("create cluster '%s': %w", name, err)
+			}
+			fmt.Printf("Cluster '%s' created.\n", name)
+			return nil
+		},
+	}
+
+	cmd.Flags().IntVarP(&opts.Machines, "machines", "m", 1, "Number of machines to create.")
+
+	return cmd
+}

cmd/ucind/cluster/remove.go

@@ -0,0 +1,30 @@
+package cluster
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"uncloud/internal/ucind"
+)
+
+func NewRemoveCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "rm [NAME]",
+		Short: "Remove a cluster.",
+		Args:  cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			p := cmd.Context().Value("provisioner").(*ucind.Provisioner)
+
+			name := DefaultClusterName
+			if len(args) > 0 {
+				name = args[0]
+			}
+
+			if err := p.RemoveCluster(cmd.Context(), name); err != nil {
+				return fmt.Errorf("remove cluster '%s': %w", name, err)
+			}
+			fmt.Printf("Cluster '%s' removed.\n", name)
+			return nil
+		},
+	}
+	return cmd
+}

cmd/ucind/cluster/root.go

@@ -0,0 +1,20 @@
+package cluster
+
+import (
+	"github.com/spf13/cobra"
+)
+
+const DefaultClusterName = "ucind-default"
+
+func NewRootCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "cluster",
+		Short: "Manage local Docker-based clusters.",
+	}
+	cmd.AddCommand(
+		NewCreateCommand(),
+		//NewListCommand(),
+		NewRemoveCommand(),
+	)
+	return cmd
+}

cmd/ucind/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/docker/client"
+	"github.com/spf13/cobra"
+	"os"
+	"strings"
+	"uncloud/cmd/ucind/cluster"
+	"uncloud/internal/ucind"
+)
+
+func main() {
+	var configPath string
+	cmd := &cobra.Command{
+		Use:   "ucind",
+		Short: "A CLI tool for running Uncloud test clusters using Docker.",
+		Long: "A CLI tool for running Uncloud test clusters using Docker.\n" +
+			"Machines in a ucind cluster are Docker containers running a ucind image. All machines within a cluster " +
+			"are connected to the same Docker network.",
+		SilenceUsage:  true,
+		SilenceErrors: true,
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+			if err != nil {
+				return fmt.Errorf("create Docker client: %w", err)
+			}
+
+			if strings.HasPrefix(configPath, "~/") {
+				home, err := os.UserHomeDir()
+				if err != nil {
+					return fmt.Errorf("get user home directory to resolve %q: %w", configPath, err)
+				}
+				configPath = strings.Replace(configPath, "~", home, 1)
+			}
+			configUpdater := ucind.NewConfigUpdater(configPath)
+
+			p := ucind.NewProvisioner(cli, configUpdater)
+			// Persist the provisioner in the context so it can be used by subcommands.
+			cmd.SetContext(context.WithValue(cmd.Context(), "provisioner", p))
+			return nil
+		},
+	}
+
+	// TODO: allow to override using UNCLOUD_CONFIG env var.
+	cmd.PersistentFlags().StringVar(&configPath, "uncloud-config", "~/.config/uncloud/config.toml",
+		"path to the Uncloud configuration file.")
+	_ = cmd.MarkPersistentFlagFilename("uncloud-config", "toml")
+
+	cmd.AddCommand(
+		cluster.NewRootCommand(),
+	)
+	cobra.CheckErr(cmd.Execute())
+}

cmd/uncloud/caddy/deploy.go

@@ -0,0 +1,247 @@
+package caddy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/charmbracelet/huh"
+	"github.com/docker/compose/v2/pkg/progress"
+	"github.com/spf13/cobra"
+	"maps"
+	"slices"
+	"strings"
+	"uncloud/internal/cli"
+	"uncloud/internal/cli/client"
+	"uncloud/internal/machine/api/pb"
+)
+
+type deployOptions struct {
+	image   string
+	machine string
+	cluster string
+}
+
+func NewDeployCommand() *cobra.Command {
+	opts := deployOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Deploy or upgrade Caddy reverse proxy across all machines in the cluster.",
+		Long: "Deploy or upgrade Caddy reverse proxy across all machines in the cluster.\n" +
+			"A rolling update is performed when updating existing containers to minimise disruption.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			return deploy(cmd.Context(), uncli, opts)
+		},
+	}
+
+	cmd.Flags().StringVar(&opts.image, "image", "",
+		"Caddy Docker image to deploy. (default caddy:LATEST_VERSION)")
+	cmd.Flags().StringVarP(&opts.machine, "machine", "m", "",
+		"Machine names to deploy to (comma-separated). (default is all machines)")
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster to deploy to. (default is the current cluster)",
+	)
+
+	return cmd
+}
+
+func deploy(ctx context.Context, uncli *cli.CLI, opts deployOptions) error {
+	clusterClient, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer clusterClient.Close()
+
+	svc, err := clusterClient.InspectService(ctx, client.CaddyServiceName)
+	if err != nil {
+		if !errors.Is(err, client.ErrNotFound) {
+			return fmt.Errorf("inspect caddy service: %w", err)
+		}
+		fmt.Printf("Service: %s (not running)\n", client.CaddyServiceName)
+	} else {
+		fmt.Printf("Service: %s (%s mode)\n", svc.Name, svc.Mode)
+
+		// Collect unique images of all containers in the running caddy service.
+		images := make(map[string]struct{}, len(svc.Containers))
+		for _, c := range svc.Containers {
+			images[c.Container.Config.Image] = struct{}{}
+		}
+		currentImages := slices.Collect(maps.Keys(images))
+
+		if len(currentImages) > 1 {
+			commaSeparatedImages := strings.Join(currentImages, ", ")
+			fmt.Printf("Current images (multiple versions detected): %s\n", commaSeparatedImages)
+		} else {
+			fmt.Printf("Current image: %s\n", currentImages[0])
+		}
+	}
+
+	if opts.image != "" {
+		fmt.Printf("Target image: %s\n", opts.image)
+	}
+
+	fmt.Println()
+	fmt.Println("Preparing a deployment plan...")
+
+	var filter client.MachineFilter
+	if opts.machine != "" {
+		machines := strings.Split(opts.machine, ",")
+		for i, m := range machines {
+			machines[i] = strings.TrimSpace(m)
+		}
+		filter = machineFilter(machines)
+	}
+
+	d, err := clusterClient.NewCaddyDeployment(opts.image, filter)
+	if err != nil {
+		return fmt.Errorf("create caddy deployment: %w", err)
+	}
+
+	// Initialize a machine and container name resolver to properly format the plan output.
+	machines, err := clusterClient.ListMachines(ctx)
+	if err != nil {
+		return fmt.Errorf("list machines: %w", err)
+	}
+	machineNames := make(map[string]string, len(machines))
+	for _, m := range machines {
+		machineNames[m.Machine.Id] = m.Machine.Name
+	}
+	containerNames := make(map[string]string, len(svc.Containers))
+	for _, c := range svc.Containers {
+		containerNames[c.Container.ID] = c.Container.NameWithoutSlash()
+	}
+	resolver := client.NewNameResolver(machineNames, containerNames)
+
+	if opts.image == "" {
+		fmt.Printf("Target image: %s (latest stable)\n", d.Spec.Container.Image)
+	}
+
+	plan, err := d.Plan(ctx)
+	if err != nil {
+		if errors.Is(err, client.ErrNoMatchingMachines) {
+			return fmt.Errorf("no machines found matching: %s", opts.machine)
+		}
+		return fmt.Errorf("plan caddy deployment: %w", err)
+	}
+
+	if len(plan.SequenceOperation.Operations) == 0 {
+		if opts.machine != "" {
+			fmt.Printf("%s service is up to date on selected machines.\n", client.CaddyServiceName)
+		} else {
+			fmt.Printf("%s service is up to date.\n", client.CaddyServiceName)
+		}
+	} else {
+		if svc.ID == "" {
+			if opts.machine != "" {
+				fmt.Println("This will run a Caddy container on selected machines.")
+			} else {
+				fmt.Println("This will run a Caddy container on each machine.")
+			}
+		} else {
+			if opts.machine != "" {
+				fmt.Println("This will perform a rolling update of Caddy containers on selected machines.")
+			} else {
+				fmt.Println("This will perform a rolling update of Caddy containers on each machine.")
+			}
+		}
+		fmt.Println()
+
+		fmt.Println("Deployment plan:")
+		fmt.Println(plan.Format(resolver))
+		fmt.Println()
+
+		confirmed, err := confirm()
+		if err != nil {
+			return fmt.Errorf("confirm deployment: %w", err)
+		}
+		if !confirmed {
+			fmt.Println("Cancelled. No changes were made.")
+			return nil
+		}
+
+		err = progress.RunWithTitle(ctx, func(ctx context.Context) error {
+			if _, err = d.Run(ctx); err != nil {
+				return fmt.Errorf("deploy caddy: %w", err)
+			}
+			return nil
+		}, uncli.ProgressOut(), fmt.Sprintf("Deploying service %s (%s mode)", d.Spec.Name, d.Spec.Mode))
+		if err != nil {
+			return err
+		}
+	}
+
+	fmt.Println()
+	if _, err = clusterClient.GetDomain(ctx); err != nil {
+		if errors.Is(err, client.ErrNotFound) {
+			fmt.Println("Skipping DNS records update as no cluster domain is reserved (see 'uc dns').")
+			return nil
+		}
+		return fmt.Errorf("get cluster domain: %w", err)
+	}
+
+	fmt.Println("Updating cluster domain records in Uncloud DNS to point to machines running caddy service...")
+	// TODO: split the method into two: one to get the records and one to update them to ask for update confirmation.
+
+	var records []*pb.DNSRecord
+	err = progress.RunWithTitle(ctx, func(ctx context.Context) error {
+		records, err = clusterClient.CreateIngressRecords(ctx, client.CaddyServiceName)
+		return err
+	}, uncli.ProgressOut(), "Verifying internet access to caddy service")
+	if err != nil {
+		if errors.Is(err, client.ErrNoReachableMachines) {
+			fmt.Println()
+			fmt.Println("DNS records could not be updated as there are no internet-reachable machines running " +
+				"caddy containers.")
+			fmt.Println()
+			fmt.Println("Possible solutions:")
+			fmt.Println("- Ensure your machines have public IP addresses")
+			fmt.Println("- Use --public-ip flag when adding machines to override the automatically detected IPs")
+			fmt.Println("- Check firewall settings on your machines")
+			fmt.Println("- Configure port forwarding if behind NAT")
+			fmt.Println("- Retry Caddy deployment after resolving connectivity issues with 'uc caddy deploy'")
+			fmt.Println()
+			fmt.Println("Your services will not be accessible from the internet until at least one machine " +
+				"becomes reachable.")
+		}
+		return fmt.Errorf("failed to update DNS records pointing to caddy service: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Println("DNS records updated to use only the internet-reachable machines running caddy service:")
+	for _, r := range records {
+		fmt.Printf("  %s  %s → %s\n", r.Name, r.Type, strings.Join(r.Values, ", "))
+	}
+
+	return nil
+}
+
+func confirm() (bool, error) {
+	var confirmed bool
+	form := huh.NewForm(
+		huh.NewGroup(
+			huh.NewConfirm().
+				Title(
+					"Do you want to continue?",
+				).
+				Affirmative("Yes!").
+				Negative("No").
+				Value(&confirmed),
+		),
+	)
+	if err := form.Run(); err != nil {
+		return false, err
+	}
+
+	return confirmed, nil
+}
+
+func machineFilter(machines []string) client.MachineFilter {
+	if len(machines) == 0 {
+		return nil
+	}
+	return func(m *pb.MachineInfo) bool {
+		return slices.Contains(machines, m.Name)
+	}
+}

cmd/uncloud/caddy/root.go

@@ -0,0 +1,16 @@
+package caddy
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func NewRootCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "caddy",
+		Short: "Manage Caddy reverse proxy service.",
+	}
+	cmd.AddCommand(
+		NewDeployCommand(),
+	)
+	return cmd
+}

cmd/uncloud/dns/release.go

@@ -0,0 +1,54 @@
+package dns
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"uncloud/internal/cli"
+)
+
+type releaseOptions struct {
+	cluster string
+}
+
+func NewReleaseCommand() *cobra.Command {
+	opts := releaseOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "release",
+		Short: "Release the reserved cluster domain.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			return release(cmd.Context(), uncli, opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+
+	return cmd
+}
+
+func release(ctx context.Context, uncli *cli.CLI, opts releaseOptions) error {
+	client, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	domain, err := client.ReleaseDomain(ctx, &emptypb.Empty{})
+	if err != nil {
+		if status.Convert(err).Code() == codes.NotFound {
+			return errors.New("no domain reserved")
+		}
+	}
+
+	fmt.Printf("Released cluster domain: %s\n", domain.Name)
+	return nil
+}

cmd/uncloud/dns/reserve.go

@@ -0,0 +1,62 @@
+package dns
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"uncloud/internal/cli"
+	"uncloud/internal/machine/api/pb"
+)
+
+const DefaultUncloudDNSAPIEndpoint = "https://dns.uncloud.run/v1"
+
+type reserveOptions struct {
+	endpoint string
+	cluster  string
+}
+
+func NewReserveCommand() *cobra.Command {
+	opts := reserveOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "reserve",
+		Short: "Reserve a cluster domain in Uncloud DNS.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			return reserve(cmd.Context(), uncli, opts)
+		},
+	}
+
+	cmd.Flags().StringVar(&opts.endpoint, "endpoint", DefaultUncloudDNSAPIEndpoint,
+		"API endpoint for the Uncloud DNS service.")
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+
+	return cmd
+}
+
+func reserve(ctx context.Context, uncli *cli.CLI, opts reserveOptions) error {
+	client, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	domain, err := client.ReserveDomain(ctx, &pb.ReserveDomainRequest{Endpoint: opts.endpoint})
+	if err != nil {
+		if status.Convert(err).Code() == codes.AlreadyExists {
+			return errors.New("domain already reserved")
+		}
+		return err
+	}
+
+	fmt.Printf("Reserved cluster domain: %s\n", domain.Name)
+	fmt.Println("Redeploy the Caddy service ('uc caddy deploy') to configure DNS records for the domain " +
+		"to route traffic to the services in the cluster.")
+	return nil
+}

cmd/uncloud/dns/root.go

@@ -0,0 +1,22 @@
+package dns
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func NewRootCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "dns",
+		Short: "Manage cluster domain in Uncloud DNS.",
+		Long: "Manage cluster domain in Uncloud DNS.\n" +
+			"DNS commands allow you to reserve or release a unique '<id>.cluster.uncloud.run' domain for your " +
+			"cluster. When reserved, Caddy service deployments will automatically update DNS records to route " +
+			"traffic to the services in the cluster.",
+	}
+	cmd.AddCommand(
+		NewReleaseCommand(),
+		NewReserveCommand(),
+		NewShowCommand(),
+	)
+	return cmd
+}

cmd/uncloud/dns/show.go

@@ -0,0 +1,53 @@
+package dns
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/spf13/cobra"
+	"uncloud/internal/cli"
+	"uncloud/internal/cli/client"
+)
+
+type showOptions struct {
+	cluster string
+}
+
+func NewShowCommand() *cobra.Command {
+	opts := showOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "show",
+		Short: "Print the cluster domain name.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			return show(cmd.Context(), uncli, opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+
+	return cmd
+}
+
+func show(ctx context.Context, uncli *cli.CLI, opts showOptions) error {
+	clusterClient, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer clusterClient.Close()
+
+	domain, err := clusterClient.GetDomain(ctx)
+	if err != nil {
+		if errors.Is(err, client.ErrNotFound) {
+			return errors.New("no domain reserved")
+		}
+		return err
+	}
+
+	fmt.Println(domain)
+	return nil
+}

cmd/uncloud/machine/add.go

@@ -1,16 +1,29 @@
 package machine
 
 import (
+	"context"
+	"errors"
 	"fmt"
+	"github.com/cenkalti/backoff/v4"
+	"github.com/docker/compose/v2/pkg/progress"
 	"github.com/spf13/cobra"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"net/netip"
+	"time"
 	"uncloud/internal/cli"
+	"uncloud/internal/cli/client"
 	"uncloud/internal/cli/config"
+	"uncloud/internal/machine/api/pb"
 )
 
 type addOptions struct {
-	name    string
-	sshKey  string
-	cluster string
+	name     string
+	noCaddy  bool
+	publicIP string
+	sshKey   string
+	cluster  string
 }
 
 func NewAddCommand() *cobra.Command {
@@ -33,17 +46,124 @@ func NewAddCommand() *cobra.Command {
 				KeyPath: opts.sshKey,
 			}
 
-			return uncli.AddMachine(cmd.Context(), remoteMachine, opts.cluster, opts.name)
+			return add(cmd.Context(), uncli, remoteMachine, opts)
 		},
 	}
-	cmd.Flags().StringVarP(&opts.name, "name", "n", "", "Assign a name to the machine")
+	cmd.Flags().StringVarP(&opts.name, "name", "n", "", "Assign a name to the machine.")
+	cmd.Flags().BoolVar(
+		&opts.noCaddy, "no-caddy", false,
+		"Don't deploy Caddy reverse proxy service to the machine.",
+	)
+	cmd.Flags().StringVar(
+		&opts.publicIP, "public-ip", "auto",
+		"Public IP address of the machine for ingress configuration. Use 'auto' for automatic detection, "+
+			"blank '' or 'none' to disable ingress on this machine, or specify an IP address.",
+	)
 	cmd.Flags().StringVarP(
 		&opts.sshKey, "ssh-key", "i", "",
-		"path to SSH private key for SSH remote login (default ~/.ssh/id_*)",
+		"path to SSH private key for SSH remote login. (default ~/.ssh/id_*)",
 	)
 	cmd.Flags().StringVarP(
 		&opts.cluster, "cluster", "c", "",
-		"Name of the cluster to add the machine to (default is the current cluster)",
+		"Name of the cluster to add the machine to. (default is the current cluster)",
 	)
 	return cmd
 }
+
+func add(ctx context.Context, uncli *cli.CLI, remoteMachine cli.RemoteMachine, opts addOptions) error {
+	var publicIP *netip.Addr
+	switch opts.publicIP {
+	case "auto":
+		publicIP = &netip.Addr{}
+	case "", "none":
+		publicIP = nil
+	default:
+		ip, err := netip.ParseAddr(opts.publicIP)
+		if err != nil {
+			return fmt.Errorf("parse public IP: %w", err)
+		}
+		publicIP = &ip
+	}
+
+	machineClient, err := uncli.AddMachine(ctx, remoteMachine, opts.cluster, opts.name, publicIP)
+	if err != nil {
+		return err
+	}
+	defer machineClient.Close()
+
+	if opts.noCaddy {
+		return nil
+	}
+
+	// Wait for the cluster to be initialised to be able to deploy the Caddy service.
+	fmt.Println("Waiting for the machine to be ready...")
+	if err = waitClusterInitialised(ctx, machineClient); err != nil {
+		return fmt.Errorf("wait for cluster to be initialised on machine: %w", err)
+	}
+
+	// Inspect the added machine to get its ID to create a filter for the Caddy deployment.
+	minfo, err := machineClient.Inspect(ctx, &emptypb.Empty{})
+	if err != nil {
+		return fmt.Errorf("inspect machine: %w", err)
+	}
+	filter := func(m *pb.MachineInfo) bool {
+		return m.Id == minfo.Id
+	}
+	// Deploy a Caddy service container to the added machine. If caddy service is already deployed on other machines,
+	// use the deployed image version. Otherwise, use the latest version.
+	caddyImage := ""
+	caddySvc, err := machineClient.InspectService(ctx, client.CaddyServiceName)
+	if err != nil {
+		if !errors.Is(err, client.ErrNotFound) {
+			return fmt.Errorf("inspect caddy service: %w", err)
+		}
+	} else {
+		caddyImage = caddySvc.Containers[0].Container.Config.Image
+		// Find the latest created container and use its image.
+		var latestCreated time.Time
+		for _, c := range caddySvc.Containers[1:] {
+			created, err := time.Parse(time.RFC3339Nano, c.Container.Created)
+			if err != nil {
+				continue
+			}
+			if created.After(latestCreated) {
+				latestCreated = created
+				caddyImage = c.Container.Config.Image
+			}
+		}
+	}
+
+	d, err := machineClient.NewCaddyDeployment(caddyImage, filter)
+	if err != nil {
+		return fmt.Errorf("create caddy deployment: %w", err)
+	}
+
+	return progress.RunWithTitle(ctx, func(ctx context.Context) error {
+		if _, err = d.Run(ctx); err != nil {
+			return fmt.Errorf("deploy caddy: %w", err)
+		}
+		return nil
+	}, uncli.ProgressOut(), fmt.Sprintf("Deploying service %s", d.Spec.Name))
+}
+
+func waitClusterInitialised(ctx context.Context, client *client.Client) error {
+	boff := backoff.WithContext(backoff.NewExponentialBackOff(
+		backoff.WithMaxInterval(1*time.Second),
+		backoff.WithMaxElapsedTime(5*time.Minute),
+	), ctx)
+
+	check := func() error {
+		_, err := client.ListMachines(ctx)
+		if err == nil {
+			return nil
+		}
+
+		statusErr := status.Convert(err)
+		if statusErr.Code() == codes.FailedPrecondition {
+			return err
+		}
+		return backoff.Permanent(err)
+	}
+
+	return backoff.Retry(check, boff)
+}

cmd/uncloud/machine/init.go

@@ -1,30 +1,32 @@
 package machine
 
 import (
+	"context"
 	"fmt"
+	"github.com/docker/compose/v2/pkg/progress"
 	"github.com/spf13/cobra"
 	"net/netip"
 	"uncloud/internal/cli"
 	"uncloud/internal/cli/config"
-	"uncloud/internal/machine/network"
+	"uncloud/internal/machine/cluster"
 )
 
 type initOptions struct {
-	name          string
-	network       string
-	userPublicKey string
-
-	sshKey  string
-	cluster string
+	name     string
+	network  string
+	noCaddy  bool
+	publicIP string
+	sshKey   string
+	cluster  string
 }
 
 func NewInitCommand() *cobra.Command {
 	opts := initOptions{}
 	cmd := &cobra.Command{
-		Use:  "init [USER@HOST:PORT]",
-		Args: cobra.MaximumNArgs(1),
-		// TODO: include usage examples of initialising a local and remote machine.
+		Use:   "init [USER@HOST:PORT]",
 		Short: "Initialise a new cluster that consists of the local or remote machine.",
+		// TODO: include usage examples of initialising a local and remote machine.
+		Args: cobra.MaximumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			uncli := cmd.Context().Value("cli").(*cli.CLI)
 
@@ -41,30 +43,83 @@ func NewInitCommand() *cobra.Command {
 					KeyPath: opts.sshKey,
 				}
 			}
-			netPrefix, err := netip.ParsePrefix(opts.network)
-			if err != nil {
-				return fmt.Errorf("parse network CIDR: %w", err)
-			}
 
-			return uncli.InitCluster(cmd.Context(), remoteMachine, opts.cluster, opts.name, netPrefix)
+			return initCluster(cmd.Context(), uncli, remoteMachine, opts)
 		},
 	}
-	cmd.Flags().StringVarP(&opts.name, "name", "n", "", "Assign a name to the machine")
+	cmd.Flags().StringVarP(
+		&opts.name, "name", "n", "",
+		"Assign a name to the machine.",
+	)
 	cmd.Flags().StringVar(
-		&opts.network, "network", network.DefaultNetwork.String(),
-		"IPv4 network CIDR to use for machines and services",
+		&opts.network, "network", cluster.DefaultNetwork.String(),
+		"IPv4 network CIDR to use for machines and services.",
+	)
+	cmd.Flags().BoolVar(
+		&opts.noCaddy, "no-caddy", false,
+		"Don't deploy Caddy reverse proxy service to the machine.",
+	)
+	cmd.Flags().StringVar(
+		&opts.publicIP, "public-ip", "auto",
+		"Public IP address of the machine for ingress configuration. Use 'auto' for automatic detection, "+
+			"blank '' or 'none' to disable ingress on this machine, or specify an IP address.",
 	)
-	//cmd.Flags().StringVar(&opts.userPublicKey, "user-pubkey", "",
-	//	"User's public key which will be able to access the cluster (hex-encoded)")
-
 	cmd.Flags().StringVarP(
 		&opts.sshKey, "ssh-key", "i", "",
-		"path to SSH private key for SSH remote login (default ~/.ssh/id_*)",
+		"path to SSH private key for SSH remote login. (default ~/.ssh/id_*)",
 	)
 	cmd.Flags().StringVarP(
 		&opts.cluster, "cluster", "c", "",
-		"Name of the cluster in the local config if initialising a remote machine",
+		"Name of the cluster in the local config if initialising a remote machine.",
 	)
 
 	return cmd
 }
+
+func initCluster(ctx context.Context, uncli *cli.CLI, remoteMachine *cli.RemoteMachine, opts initOptions) error {
+	netPrefix, err := netip.ParsePrefix(opts.network)
+	if err != nil {
+		return fmt.Errorf("parse network CIDR: %w", err)
+	}
+
+	var publicIP *netip.Addr
+	switch opts.publicIP {
+	case "auto":
+		publicIP = &netip.Addr{}
+	case "", "none":
+		publicIP = nil
+	default:
+		ip, err := netip.ParseAddr(opts.publicIP)
+		if err != nil {
+			return fmt.Errorf("parse public IP: %w", err)
+		}
+		publicIP = &ip
+	}
+
+	client, err := uncli.InitCluster(ctx, remoteMachine, opts.cluster, opts.name, netPrefix, publicIP)
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	if opts.noCaddy {
+		return nil
+	}
+
+	// Deploy the Caddy service to the initialised machine.
+	// The creation of a deployment plan talks to cluster API. Since the API needs a few moments to become available
+	// after cluster initialisation, we keep the user informed during this wait.
+	fmt.Println("Waiting for the machine to be ready...")
+
+	d, err := client.NewCaddyDeployment("", nil)
+	if err != nil {
+		return fmt.Errorf("create caddy deployment: %w", err)
+	}
+
+	return progress.RunWithTitle(ctx, func(ctx context.Context) error {
+		if _, err = d.Run(ctx); err != nil {
+			return fmt.Errorf("deploy caddy: %w", err)
+		}
+		return nil
+	}, uncli.ProgressOut(), fmt.Sprintf("Deploying service %s", d.Spec.Name))
+}

cmd/uncloud/machine/list.go

@@ -1,24 +1,84 @@
 package machine
 
 import (
+	"context"
+	"fmt"
 	"github.com/spf13/cobra"
+	"net/netip"
+	"os"
+	"strings"
+	"text/tabwriter"
 	"uncloud/internal/cli"
+	"uncloud/internal/machine/network"
 )
 
 func NewListCommand() *cobra.Command {
-	opts := addOptions{}
+	var cluster string
 	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"ls"},
-		Short:   "List machines in a cluster",
+		Use:     "ls",
+		Aliases: []string{"list"},
+		Short:   "List machines in a cluster.",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			uncli := cmd.Context().Value("cli").(*cli.CLI)
-			return uncli.ListMachines(cmd.Context(), opts.cluster)
+			return list(cmd.Context(), uncli, cluster)
 		},
 	}
 	cmd.Flags().StringVarP(
-		&opts.cluster, "cluster", "c", "",
-		"Name of the cluster (default is the current cluster)",
+		&cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
 	)
 	return cmd
 }
+
+func list(ctx context.Context, uncli *cli.CLI, clusterName string) error {
+	client, err := uncli.ConnectCluster(ctx, clusterName)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	machines, err := client.ListMachines(ctx)
+	if err != nil {
+		return fmt.Errorf("list machines: %w", err)
+	}
+
+	// Print the list of machines in a table format.
+	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
+	// Print header.
+	if _, err = fmt.Fprintln(tw, "NAME\tSTATE\tADDRESS\tPUBLIC IP\tWIREGUARD ENDPOINTS"); err != nil {
+		return fmt.Errorf("write header: %w", err)
+	}
+	// Print rows.
+	for _, member := range machines {
+		m := member.Machine
+		subnet, _ := m.Network.Subnet.ToPrefix()
+		subnet = netip.PrefixFrom(network.MachineIP(subnet), subnet.Bits())
+
+		publicIP := "-"
+		if m.PublicIp != nil {
+			ip, _ := m.PublicIp.ToAddr()
+			publicIP = ip.String()
+		}
+
+		endpoints := make([]string, len(m.Network.Endpoints))
+		for i, ep := range m.Network.Endpoints {
+			addrPort, _ := ep.ToAddrPort()
+			endpoints[i] = addrPort.String()
+		}
+
+		if _, err = fmt.Fprintf(
+			tw, "%s\t%s\t%s\t%s\t%s\n", m.Name, capitalise(member.State.String()), subnet, publicIP, strings.Join(endpoints, ", "),
+		); err != nil {
+			return fmt.Errorf("write row: %w", err)
+		}
+	}
+	return tw.Flush()
+}
+
+// capitalise returns a string where the first character is upper case, and the rest is lower case.
+func capitalise(s string) string {
+	if s == "" {
+		return ""
+	}
+	return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
+}

cmd/uncloud/machine/token.go

@@ -31,7 +31,7 @@ func NewTokenCommand() *cobra.Command {
 	}
 
 	cmd.Flags().StringVarP(&opts.dataDir, "data-dir", "d", machine.DefaultDataDir,
-		"Directory for storing persistent machine state")
+		"Directory for storing persistent machine state.")
 	_ = cmd.MarkFlagDirname("data-dir")
 
 	return cmd

cmd/uncloud/main.go

@@ -6,7 +6,10 @@ import (
 	"github.com/spf13/cobra"
 	"os"
 	"strings"
+	"uncloud/cmd/uncloud/caddy"
+	"uncloud/cmd/uncloud/dns"
 	"uncloud/cmd/uncloud/machine"
+	"uncloud/cmd/uncloud/service"
 	"uncloud/internal/cli"
 )
 
@@ -36,11 +39,18 @@ func main() {
 	}
 	// TODO: allow to override using UNCLOUD_CONFIG env var.
 	cmd.PersistentFlags().StringVar(&configPath, "uncloud-config", "~/.config/uncloud/config.toml",
-		"path to the Uncloud configuration file")
+		"path to the Uncloud configuration file.")
 	_ = cmd.MarkPersistentFlagFilename("uncloud-config", "toml")
 
 	cmd.AddCommand(
+		caddy.NewRootCommand(),
+		dns.NewRootCommand(),
 		machine.NewRootCommand(),
+		service.NewRootCommand(),
+		service.NewInspectCommand(),
+		service.NewListCommand(),
+		service.NewRmCommand(),
+		service.NewRunCommand(),
 	)
 	cobra.CheckErr(cmd.Execute())
 }

cmd/uncloud/service/inspect.go

@@ -0,0 +1,102 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/docker/pkg/stringid"
+	"github.com/docker/go-units"
+	"os"
+	"text/tabwriter"
+	"time"
+
+	"github.com/spf13/cobra"
+	"uncloud/internal/cli"
+)
+
+type inspectOptions struct {
+	service string
+	cluster string
+}
+
+func NewInspectCommand() *cobra.Command {
+	opts := inspectOptions{}
+	cmd := &cobra.Command{
+		Use:   "inspect",
+		Short: "Display detailed information on a service.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			opts.service = args[0]
+			return inspect(cmd.Context(), uncli, opts)
+		},
+	}
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+	return cmd
+}
+
+func inspect(ctx context.Context, uncli *cli.CLI, opts inspectOptions) error {
+	client, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	svc, err := client.InspectService(ctx, opts.service)
+	if err != nil {
+		return fmt.Errorf("inspect service: %w", err)
+	}
+
+	machines, err := client.ListMachines(ctx)
+	if err != nil {
+		return fmt.Errorf("list machines: %w", err)
+	}
+	machinesNamesByID := make(map[string]string)
+	for _, m := range machines {
+		machinesNamesByID[m.Machine.Id] = m.Machine.Name
+	}
+
+	fmt.Printf("ID:    %s\n", svc.ID)
+	fmt.Printf("Name:  %s\n", svc.Name)
+	fmt.Printf("Mode:  %s\n", svc.Mode)
+	fmt.Println()
+
+	// Print the list of containers in a table format.
+	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
+	if _, err = fmt.Fprintln(tw, "CONTAINER ID\tIMAGE\tCREATED\tSTATUS\tMACHINE"); err != nil {
+		return fmt.Errorf("write header: %w", err)
+	}
+
+	for _, ctr := range svc.Containers {
+		createdAt, err := time.Parse(time.RFC3339Nano, ctr.Container.Created)
+		if err != nil {
+			return fmt.Errorf("parse created time: %w", err)
+		}
+		created := units.HumanDuration(time.Now().UTC().Sub(createdAt)) + " ago"
+
+		machine := machinesNamesByID[ctr.MachineID]
+		if machine == "" {
+			machine = ctr.MachineID
+		}
+		state, err := ctr.Container.HumanState()
+		if err != nil {
+			return fmt.Errorf("get human state: %w", err)
+		}
+
+		_, err = fmt.Fprintf(
+			tw,
+			"%s\t%s\t%s\t%s\t%s\n",
+			stringid.TruncateID(ctr.Container.ID),
+			ctr.Container.Config.Image,
+			created,
+			state,
+			machine,
+		)
+		if err != nil {
+			return fmt.Errorf("write row: %w", err)
+		}
+	}
+	return tw.Flush()
+}

cmd/uncloud/service/list.go

@@ -0,0 +1,79 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"strings"
+	"text/tabwriter"
+	"uncloud/internal/cli"
+)
+
+func NewListCommand() *cobra.Command {
+	var cluster string
+	cmd := &cobra.Command{
+		Use:     "ls",
+		Aliases: []string{"list"},
+		Short:   "List services.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			return list(cmd.Context(), uncli, cluster)
+		},
+	}
+	cmd.Flags().StringVarP(
+		&cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+	return cmd
+}
+
+func list(ctx context.Context, uncli *cli.CLI, clusterName string) error {
+	client, err := uncli.ConnectCluster(ctx, clusterName)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	services, err := client.ListServices(ctx)
+	if err != nil {
+		return fmt.Errorf("list services: %w", err)
+	}
+
+	serviceNames := make(map[string]struct{}, len(services))
+	haveDuplicateNames := false
+	for _, svc := range services {
+		if _, exists := serviceNames[svc.Name]; exists {
+			haveDuplicateNames = true
+			break
+		}
+		serviceNames[svc.Name] = struct{}{}
+	}
+
+	// Print the list of services in a table format.
+	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
+
+	// Include the ID column if there are duplicate service names to differentiate them.
+	if haveDuplicateNames {
+		if _, err = fmt.Fprintf(tw, "ID\t"); err != nil {
+			return fmt.Errorf("write header: %w", err)
+		}
+	}
+	if _, err = fmt.Fprintln(tw, "NAME\tMODE\tREPLICAS\tENDPOINTS"); err != nil {
+		return fmt.Errorf("write header: %w", err)
+	}
+	for _, s := range services {
+		endpointsSlice := s.Endpoints()
+		endpoints := strings.Join(endpointsSlice, ", ")
+
+		if haveDuplicateNames {
+			if _, err = fmt.Fprintf(tw, "%s\t", s.ID); err != nil {
+				return fmt.Errorf("write row: %w", err)
+			}
+		}
+		if _, err = fmt.Fprintf(tw, "%s\t%s\t%d\t%s\n", s.Name, s.Mode, len(s.Containers), endpoints); err != nil {
+			return fmt.Errorf("write row: %w", err)
+		}
+	}
+	return tw.Flush()
+}

cmd/uncloud/service/rm.go

@@ -0,0 +1,55 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/cli/cli/streams"
+	"github.com/docker/compose/v2/pkg/progress"
+	"github.com/spf13/cobra"
+	"os"
+	"uncloud/internal/cli"
+)
+
+type rmOptions struct {
+	services []string
+	cluster  string
+}
+
+func NewRmCommand() *cobra.Command {
+	opts := rmOptions{}
+	cmd := &cobra.Command{
+		Use:     "rm SERVICE [SERVICE...]",
+		Aliases: []string{"remove", "delete"},
+		Short:   "Remove one or more services.",
+		Args:    cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+			opts.services = args
+			return rm(cmd.Context(), uncli, opts)
+		},
+	}
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster. (default is the current cluster)",
+	)
+	return cmd
+}
+
+func rm(ctx context.Context, uncli *cli.CLI, opts rmOptions) error {
+	client, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	for _, s := range opts.services {
+		err = progress.RunWithTitle(ctx, func(ctx context.Context) error {
+			if err = client.RemoveService(ctx, s); err != nil {
+				return fmt.Errorf("remove service '%s': %w", s, err)
+			}
+			return nil
+		}, streams.NewOut(os.Stdout), "Removing service "+s)
+	}
+
+	return nil
+}

cmd/uncloud/service/root.go

@@ -0,0 +1,19 @@
+package service
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func NewRootCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "service",
+		Short: "Manage services in an Uncloud cluster.",
+	}
+	cmd.AddCommand(
+		NewInspectCommand(),
+		NewListCommand(),
+		NewRmCommand(),
+		NewRunCommand(),
+	)
+	return cmd
+}

cmd/uncloud/service/run.go

@@ -0,0 +1,158 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"github.com/spf13/cobra"
+	"slices"
+	"strings"
+	"uncloud/internal/api"
+	"uncloud/internal/cli"
+	"uncloud/internal/cli/client"
+	"uncloud/internal/machine/api/pb"
+)
+
+type runOptions struct {
+	command  []string
+	image    string
+	machines []string
+	mode     string
+	name     string
+	publish  []string
+	replicas uint
+	volumes  []string
+
+	cluster string
+}
+
+func NewRunCommand() *cobra.Command {
+	opts := runOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "run IMAGE [COMMAND...]",
+		Short: "Run a service.",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			uncli := cmd.Context().Value("cli").(*cli.CLI)
+
+			opts.image = args[0]
+			if len(args) > 1 {
+				opts.command = args[1:]
+			}
+
+			return run(cmd.Context(), uncli, opts)
+		},
+	}
+
+	cmd.Flags().StringVar(&opts.mode, "mode", api.ServiceModeReplicated,
+		fmt.Sprintf("Replication mode of the service: either %q (a specified number of containers across "+
+			"the machines) or %q (one container on every machine).",
+			api.ServiceModeReplicated, api.ServiceModeGlobal))
+	cmd.Flags().StringSliceVarP(&opts.machines, "machine", "m", nil,
+		"Placement constraint by machine name, limiting which machines the service can run on. Can be specified "+
+			"multiple times or as a comma-separated list of machine names. (default is any suitable machine)")
+	cmd.Flags().StringVarP(&opts.name, "name", "n", "",
+		"Assign a name to the service. A random name is generated if not specified.")
+	cmd.Flags().StringSliceVarP(&opts.publish, "publish", "p", nil,
+		"Publish a service port to make it accessible outside the cluster. Can be specified multiple times.\n"+
+			"Format: [hostname:][load_balancer_port:]container_port[/protocol] or [host_ip:]:host_port:container_port[/protocol]@host\n"+
+			"Supported protocols: tcp, udp, http, https (default is tcp). If a hostname for http(s) port is not specified,\n"+
+			"service-name.cluster-domain will be used as the hostname.\n"+
+			"Examples:\n"+
+			"  -p 8080/https                  Publish port 8080 as HTTPS via load balancer with default service-name.cluster-domain hostname\n"+
+			"  -p app.example.com:8080/https  Publish port 8080 as HTTPS via load balancer with custom hostname\n"+
+			"  -p 9000:8080                   Publish port 8080 as TCP port 9000 via load balancer\n"+
+			"  -p 53:5353/udp@host            Bind UDP port 5353 to host port 53")
+	cmd.Flags().UintVar(&opts.replicas, "replicas", 1,
+		"Number of containers to run for the service. Only valid for a replicated service.")
+	cmd.Flags().StringSliceVarP(&opts.volumes, "volume", "v", nil,
+		"Bind mount a host file or directory into a service container using the format "+
+			"/host/path:/container/path[:ro]. Can be specified multiple times.")
+
+	cmd.Flags().StringVarP(
+		&opts.cluster, "cluster", "c", "",
+		"Name of the cluster to run the service in. (default is the current cluster)",
+	)
+
+	return cmd
+}
+
+func run(ctx context.Context, uncli *cli.CLI, opts runOptions) error {
+	switch opts.mode {
+	case api.ServiceModeReplicated, api.ServiceModeGlobal:
+	default:
+		return fmt.Errorf("invalid replication mode: %q", opts.mode)
+	}
+
+	var machineFilter client.MachineFilter
+	if len(opts.machines) > 0 {
+		var machines []string
+		for _, value := range opts.machines {
+			if value == "" {
+				continue
+			}
+
+			mlist := strings.Split(value, ",")
+			for _, m := range mlist {
+				if m = strings.TrimSpace(m); m != "" {
+					machines = append(machines, m)
+				}
+			}
+		}
+
+		if len(machines) > 0 {
+			machineFilter = func(m *pb.MachineInfo) bool {
+				return slices.Contains(machines, m.Name)
+			}
+		}
+	}
+
+	ports := make([]api.PortSpec, len(opts.publish))
+	for i, publishPort := range opts.publish {
+		port, err := api.ParsePortSpec(publishPort)
+		if err != nil {
+			return fmt.Errorf("invalid service port '%s': %w", publishPort, err)
+		}
+		ports[i] = port
+	}
+	// TODO: parse and validate opts.volumes to fail fast if invalid.
+
+	spec := api.ServiceSpec{
+		Container: api.ContainerSpec{
+			Command: opts.command,
+			Image:   opts.image,
+			Volumes: opts.volumes,
+		},
+		Mode:     opts.mode,
+		Name:     opts.name,
+		Ports:    ports,
+		Replicas: opts.replicas,
+	}
+	if err := spec.Validate(); err != nil {
+		return fmt.Errorf("invalid service configuration: %w", err)
+	}
+
+	client, err := uncli.ConnectCluster(ctx, opts.cluster)
+	if err != nil {
+		return fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer client.Close()
+
+	resp, err := client.RunService(ctx, spec, machineFilter)
+	if err != nil {
+		return fmt.Errorf("run service: %w", err)
+	}
+
+	svc, err := client.InspectService(ctx, resp.ID)
+	if err != nil {
+		return fmt.Errorf("inspect service: %w", err)
+	}
+
+	fmt.Println()
+	fmt.Printf("%s endpoints:\n", svc.Name)
+	for _, endpoint := range svc.Endpoints() {
+		fmt.Printf(" • %s\n", endpoint)
+	}
+
+	return nil
+}

cmd/uncloudd/main.go

@@ -8,11 +8,15 @@ import (
 	"os/signal"
 	"syscall"
 	"uncloud/internal/daemon"
+	"uncloud/internal/log"
 	"uncloud/internal/machine"
 )
 
 func main() {
-	slog.SetLogLoggerLevel(slog.LevelDebug)
+	logger := slog.New(log.NewSlogTextHandler(os.Stderr, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+	}))
+	slog.SetDefault(logger)
 
 	var dataDir string
 	cmd := &cobra.Command{

go.mod

@@ -1,16 +1,25 @@
 module uncloud
 
-go 1.22.2
+go 1.23.0
 
-toolchain go1.22.5
+toolchain go1.23.2
 
 require (
 	github.com/BurntSushi/toml v1.4.0
+	github.com/Masterminds/semver v1.5.0
+	github.com/Masterminds/squirrel v1.5.4
+	github.com/caddyserver/caddy/v2 v2.8.4
+	github.com/cenkalti/backoff/v4 v4.3.0
 	github.com/charmbracelet/huh v0.6.0
 	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf
 	github.com/dgraph-io/badger/v3 v3.2103.5
-	github.com/docker/docker v27.3.0+incompatible
+	github.com/distribution/reference v0.6.0
+	github.com/docker/cli v27.5.0+incompatible
+	github.com/docker/compose/v2 v2.31.0
+	github.com/docker/docker v27.4.0-rc.2+incompatible
 	github.com/docker/go-connections v0.5.0
+	github.com/docker/go-units v0.5.0
+	github.com/google/go-containerregistry v0.20.2
 	github.com/hashicorp/memberlist v0.5.1
 	github.com/hashicorp/serf v0.10.1
 	github.com/ipfs/boxo v0.21.0
@@ -21,34 +30,49 @@ require (
 	github.com/ipfs/go-ipld-format v0.6.0
 	github.com/ipfs/go-log/v2 v2.5.1
 	github.com/lmittmann/tint v1.0.5
+	github.com/opencontainers/image-spec v1.1.0
 	github.com/siderolabs/discovery-api v0.1.4
 	github.com/siderolabs/discovery-client v0.1.9
+	github.com/siderolabs/grpc-proxy v0.5.1
 	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.10.0
 	github.com/vishvananda/netlink v1.3.0
 	go.uber.org/zap v1.27.0
 	go4.org/netipx v0.0.0-20231129151722-fdeea329fbba
-	golang.org/x/crypto v0.27.0
-	golang.org/x/sync v0.8.0
-	golang.org/x/sys v0.25.0
+	golang.org/x/crypto v0.32.0
+	golang.org/x/net v0.34.0
+	golang.org/x/sync v0.10.0
+	golang.org/x/sys v0.29.0
 	golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6
-	google.golang.org/grpc v1.66.0
-	google.golang.org/protobuf v1.34.2
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20241209162323-e6fa225c2576
+	google.golang.org/grpc v1.68.1
+	google.golang.org/protobuf v1.36.3
 )
 
 require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect
+	github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
 	github.com/Masterminds/goutils v1.1.1 // indirect
 	github.com/Masterminds/semver/v3 v3.2.1 // indirect
 	github.com/Masterminds/sprig/v3 v3.2.3 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/OneOfOne/xxhash v1.2.8 // indirect
+	github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
 	github.com/armon/circbuf v0.0.0-20190214190532-5111143e8da2 // indirect
 	github.com/armon/go-metrics v0.4.1 // indirect
 	github.com/armon/go-radix v1.0.0 // indirect
+	github.com/aryann/difflib v0.0.0-20210328193216-ff5ff6dc229b // indirect
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bgentry/speakeasy v0.2.0 // indirect
+	github.com/buger/goterm v1.0.4 // indirect
+	github.com/caddyserver/certmagic v0.21.4 // indirect
+	github.com/caddyserver/zerossl v0.1.3 // indirect
 	github.com/catppuccin/go v0.2.0 // indirect
-	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charmbracelet/bubbles v0.20.0 // indirect
@@ -57,28 +81,62 @@ require (
 	github.com/charmbracelet/x/ansi v0.3.2 // indirect
 	github.com/charmbracelet/x/exp/strings v0.0.0-20240919170804-a4978c8e603a // indirect
 	github.com/charmbracelet/x/term v0.2.0 // indirect
+	github.com/chzyer/readline v1.5.1 // indirect
+	github.com/cloudflare/cfssl v1.6.4 // indirect
+	github.com/compose-spec/compose-go/v2 v2.4.5 // indirect
+	github.com/containerd/console v1.0.4 // indirect
+	github.com/containerd/containerd v1.7.24 // indirect
+	github.com/containerd/containerd/api v1.7.19 // indirect
+	github.com/containerd/continuity v0.4.4 // indirect
+	github.com/containerd/errdefs v0.3.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
+	github.com/containerd/platforms v0.2.1 // indirect
+	github.com/containerd/stargz-snapshotter/estargz v0.16.3 // indirect
+	github.com/containerd/ttrpc v1.2.5 // indirect
+	github.com/containerd/typeurl/v2 v2.2.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect
+	github.com/dgraph-io/badger v1.6.2 // indirect
+	github.com/dgraph-io/badger/v2 v2.2007.4 // indirect
 	github.com/dgraph-io/ristretto v0.1.1 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
+	github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 // indirect
+	github.com/docker/buildx v0.18.0 // indirect
+	github.com/docker/distribution v2.8.3+incompatible // indirect
+	github.com/docker/docker-credential-helpers v0.8.2 // indirect
+	github.com/docker/go v1.5.1-1.0.20160303222718-d30aec9fd63c // indirect
 	github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect
-	github.com/docker/go-units v0.5.0 // indirect
+	github.com/docker/go-metrics v0.0.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/fatih/color v1.17.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fvbommel/sortorder v1.1.0 // indirect
+	github.com/go-jose/go-jose/v3 v3.0.3 // indirect
+	github.com/go-kit/kit v0.13.0 // indirect
+	github.com/go-kit/log v0.2.1 // indirect
+	github.com/go-logfmt/logfmt v0.6.0 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
+	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.0.0 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
+	github.com/gofrs/flock v0.12.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v1.2.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/btree v1.1.2 // indirect
+	github.com/google/cel-go v0.20.1 // indirect
 	github.com/google/flatbuffers v24.3.25+incompatible // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/pprof v0.0.0-20241210010833-40e02aabc2ad // indirect
+	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/mux v1.8.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.24.0 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
 	github.com/hashicorp/go-msgpack v0.5.5 // indirect
@@ -86,12 +144,14 @@ require (
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/hashicorp/go-sockaddr v1.0.6 // indirect
 	github.com/hashicorp/go-syslog v1.0.0 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/hashicorp/logutils v1.0.0 // indirect
 	github.com/hashicorp/mdns v1.0.5 // indirect
 	github.com/huandu/xstrings v1.5.0 // indirect
 	github.com/imdario/mergo v0.3.16 // indirect
+	github.com/in-toto/in-toto-golang v0.5.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/ipfs/bbloom v0.0.4 // indirect
 	github.com/ipfs/go-block-format v0.2.0 // indirect
@@ -101,30 +161,53 @@ require (
 	github.com/ipld/go-codec-dagpb v1.6.0 // indirect
 	github.com/ipld/go-ipld-prime v0.21.0 // indirect
 	github.com/ishidawataru/sctp v0.0.0-20230406120618-7ff4192f6ff2 // indirect
+	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
+	github.com/jackc/pgconn v1.14.3 // indirect
+	github.com/jackc/pgio v1.0.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgproto3/v2 v2.3.3 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/pgtype v1.14.0 // indirect
+	github.com/jackc/pgx/v4 v4.18.3 // indirect
 	github.com/jbenet/goprocess v0.1.4 // indirect
 	github.com/josharian/native v1.1.0 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
+	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
+	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
+	github.com/libdns/libdns v0.2.2 // indirect
 	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
 	github.com/libp2p/go-libp2p v0.35.4 // indirect
 	github.com/libp2p/go-libp2p-pubsub v0.11.0 // indirect
 	github.com/libp2p/go-msgio v0.3.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/manifoldco/promptui v0.9.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/mattn/go-shellwords v1.0.12 // indirect
 	github.com/mdlayher/genetlink v1.3.2 // indirect
 	github.com/mdlayher/netlink v1.7.2 // indirect
 	github.com/mdlayher/socket v0.5.1 // indirect
+	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
+	github.com/mholt/acmez/v2 v2.0.3 // indirect
 	github.com/miekg/dns v1.1.62 // indirect
+	github.com/miekg/pkcs11 v1.1.1 // indirect
 	github.com/minio/sha256-simd v1.0.1 // indirect
 	github.com/mitchellh/cli v1.1.5 // indirect
 	github.com/mitchellh/copystructure v1.2.0 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/go-ps v1.0.0 // indirect
 	github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mitchellh/reflectwalk v1.0.2 // indirect
+	github.com/moby/buildkit v0.17.2 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/moby/locker v1.0.1 // indirect
+	github.com/moby/patternmatcher v0.6.0 // indirect
+	github.com/moby/sys/sequential v0.6.0 // indirect
+	github.com/moby/sys/signal v0.7.1 // indirect
 	github.com/moby/term v0.5.0 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/mr-tron/base58 v1.2.0 // indirect
@@ -140,37 +223,87 @@ require (
 	github.com/multiformats/go-multihash v0.2.3 // indirect
 	github.com/multiformats/go-multistream v0.5.0 // indirect
 	github.com/multiformats/go-varint v0.0.7 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/onsi/ginkgo/v2 v2.22.0 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0 // indirect
+	github.com/pelletier/go-toml v1.9.5 // indirect
+	github.com/pires/go-proxyproto v0.7.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/polydawn/refmt v0.89.0 // indirect
 	github.com/posener/complete v1.2.3 // indirect
+	github.com/prometheus/client_golang v1.20.5 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.61.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.48.2 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rs/xid v1.5.0 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect
+	github.com/secure-systems-lab/go-securesystemslib v0.4.0 // indirect
+	github.com/shibumi/go-pathspec v1.3.0 // indirect
 	github.com/shopspring/decimal v1.4.0 // indirect
+	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
 	github.com/siderolabs/gen v0.4.8 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/slackhq/nebula v1.6.1 // indirect
+	github.com/smallstep/certificates v0.26.1 // indirect
+	github.com/smallstep/nosql v0.6.1 // indirect
+	github.com/smallstep/pkcs7 v0.0.0-20231024181729-3b98ecc1ca81 // indirect
+	github.com/smallstep/scep v0.0.0-20231024192529-aee96d7ad34d // indirect
+	github.com/smallstep/truststore v0.13.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/spf13/cast v1.7.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/stoewer/go-strcase v1.2.0 // indirect
+	github.com/tailscale/tscert v0.0.0-20240517230440-bbccfbf48933 // indirect
+	github.com/theupdateframework/notary v0.7.0 // indirect
+	github.com/tonistiigi/dchapes-mode v0.0.0-20241001053921-ca0759fec205 // indirect
+	github.com/tonistiigi/fsutil v0.0.0-20241028165955-397af5306b5c // indirect
+	github.com/tonistiigi/go-csvvalue v0.0.0-20240710180619-ddb21b71c0b4 // indirect
+	github.com/tonistiigi/units v0.0.0-20180711220420-6950e57a87ea // indirect
+	github.com/tonistiigi/vt100 v0.0.0-20240514184818-90bafcd6abab // indirect
+	github.com/urfave/cli v1.22.16 // indirect
+	github.com/vbatts/tar-split v0.11.6 // indirect
 	github.com/vishvananda/netns v0.0.4 // indirect
+	github.com/zeebo/blake3 v0.2.4 // indirect
+	go.etcd.io/bbolt v1.3.11 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.52.0 // indirect
-	go.opentelemetry.io/otel v1.30.0 // indirect
-	go.opentelemetry.io/otel/metric v1.30.0 // indirect
-	go.opentelemetry.io/otel/trace v1.30.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.46.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.58.0 // indirect
+	go.opentelemetry.io/otel v1.33.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.44.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.33.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 // indirect
+	go.opentelemetry.io/otel/metric v1.33.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.33.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.32.0 // indirect
+	go.opentelemetry.io/otel/trace v1.33.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.4.0 // indirect
+	go.step.sm/cli-utils v0.9.0 // indirect
+	go.step.sm/crypto v0.45.0 // indirect
+	go.step.sm/linkedca v0.20.1 // indirect
+	go.uber.org/automaxprocs v1.5.3 // indirect
+	go.uber.org/mock v0.5.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect
-	golang.org/x/mod v0.21.0 // indirect
-	golang.org/x/net v0.29.0 // indirect
-	golang.org/x/text v0.18.0 // indirect
-	golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 // indirect
-	golang.org/x/tools v0.25.0 // indirect
+	go.uber.org/zap/exp v0.2.0 // indirect
+	golang.org/x/crypto/x509roots/fallback v0.0.0-20240507223354-67b13616a595 // indirect
+	golang.org/x/exp v0.0.0-20241215155358-4a5509556b9e // indirect
+	golang.org/x/mod v0.22.0 // indirect
+	golang.org/x/term v0.28.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/time v0.8.0 // indirect
+	golang.org/x/tools v0.29.0 // indirect
 	golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240827150818-7e3bb234dfed // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240827150818-7e3bb234dfed // indirect
-	gotest.tools/v3 v3.5.1 // indirect
+	google.golang.org/genproto v0.0.0-20240401170217-c3f982113cda // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20241209162323-e6fa225c2576 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 	gvisor.dev/gvisor v0.0.0-20230927004350-cbd86285d259 // indirect
+	howett.net/plist v1.0.0 // indirect
 	lukechampine.com/blake3 v1.3.0 // indirect
 )

internal/api/container.go

@@ -0,0 +1,185 @@
+package api
+
+import (
+	"fmt"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/go-units"
+	"strings"
+	"time"
+)
+
+const (
+	LabelManaged      = "uncloud.managed"
+	LabelServiceID    = "uncloud.service.id"
+	LabelServiceName  = "uncloud.service.name"
+	LabelServiceMode  = "uncloud.service.mode"
+	LabelServicePorts = "uncloud.service.ports"
+)
+
+type Container struct {
+	types.ContainerJSON
+}
+
+// NameWithoutSlash returns the container name without the leading slash.
+// TODO: modify Name in original ContainerJSON structure when inspecting a Docker container and get rid of this method.
+func (c *Container) NameWithoutSlash() string {
+	return c.Name[1:]
+}
+
+// ServiceID returns the ID of the service this container belongs to.
+func (c *Container) ServiceID() string {
+	return c.Config.Labels[LabelServiceID]
+}
+
+// ServiceName returns the name of the service this container belongs to.
+func (c *Container) ServiceName() string {
+	return c.Config.Labels[LabelServiceName]
+}
+
+// ServiceMode returns the replication mode of the service this container belongs to.
+func (c *Container) ServiceMode() string {
+	return c.Config.Labels[LabelServiceMode]
+}
+
+// ServicePorts returns the ports this container publishes as part of its service.
+func (c *Container) ServicePorts() ([]PortSpec, error) {
+	encoded, ok := c.Config.Labels[LabelServicePorts]
+	if !ok {
+		return nil, nil
+	}
+	if strings.TrimSpace(encoded) == "" {
+		return nil, nil
+	}
+
+	publishPorts := strings.Split(encoded, ",")
+	ports := make([]PortSpec, len(publishPorts))
+	for i, p := range publishPorts {
+		port, err := ParsePortSpec(strings.TrimSpace(p))
+		if err != nil {
+			return nil, err
+		}
+		ports[i] = port
+	}
+
+	return ports, nil
+}
+
+// ServiceSpec constructs a service spec from the container's configuration.
+func (c *Container) ServiceSpec() (ServiceSpec, error) {
+	ports, err := c.ServicePorts()
+	if err != nil {
+		return ServiceSpec{}, fmt.Errorf("get service ports: %w", err)
+	}
+
+	return ServiceSpec{
+		Container: ContainerSpec{
+			Command: c.Config.Cmd,
+			Image:   c.Config.Image,
+			Init:    c.HostConfig.Init,
+			Volumes: c.HostConfig.Binds,
+		},
+		Mode:  c.ServiceMode(),
+		Name:  c.ServiceName(),
+		Ports: ports,
+	}, nil
+}
+
+// Healthy determines if the container is running and healthy.
+// A running container with no health check configured is considered healthy.
+func (c *Container) Healthy() bool {
+	if !c.State.Running || c.State.Paused || c.State.Restarting {
+		return false
+	}
+
+	// If there's no health status (no health check configured), container is considered healthy.
+	if c.State.Health == nil {
+		return true
+	}
+
+	return c.State.Health.Status == types.Healthy
+}
+
+// HumanState returns a human-readable description of the container's state. Based on the Docker implementation:
+// https://github.com/moby/moby/blob/b343d235a0a1f30c8f05b1d651238e72158dc25d/container/state.go#L79-L113
+func (c *Container) HumanState() (string, error) {
+	startedAt, err := time.Parse(time.RFC3339Nano, c.State.StartedAt)
+	if err != nil {
+		return "", fmt.Errorf("parse started time: %w", err)
+	}
+	finishedAt, err := time.Parse(time.RFC3339Nano, c.State.FinishedAt)
+	if err != nil {
+		return "", fmt.Errorf("parse finished time: %w", err)
+	}
+
+	if c.State.Running {
+		if c.State.Paused {
+			return fmt.Sprintf("Up %s (Paused)", units.HumanDuration(time.Now().UTC().Sub(startedAt))), nil
+		}
+		if c.State.Restarting {
+			return fmt.Sprintf("Restarting (%d) %s ago",
+				c.State.ExitCode, units.HumanDuration(time.Now().UTC().Sub(finishedAt))), nil
+		}
+
+		if c.State.Health != nil {
+			status := c.State.Health.Status
+			if status == types.Starting {
+				status = "health: " + status
+			}
+
+			return fmt.Sprintf("Up %s (%s)", units.HumanDuration(time.Now().UTC().Sub(startedAt)), status), nil
+		}
+
+		return fmt.Sprintf("Up %s", units.HumanDuration(time.Now().UTC().Sub(startedAt))), nil
+	}
+
+	if c.State.Status == "removing" {
+		return "Removal In Progress", nil
+	}
+
+	if c.State.Dead {
+		return "Dead", nil
+	}
+
+	if startedAt.IsZero() {
+		return "Created", nil
+	}
+
+	if finishedAt.IsZero() {
+		return "", nil
+	}
+
+	return fmt.Sprintf("Exited (%d) %s ago",
+		c.State.ExitCode, units.HumanDuration(time.Now().UTC().Sub(finishedAt))), nil
+}
+
+// ConflictingServicePorts returns a list of service ports that conflict with the given ports.
+func (c *Container) ConflictingServicePorts(ports []PortSpec) ([]PortSpec, error) {
+	svcPorts, err := c.ServicePorts()
+	if err != nil {
+		return nil, fmt.Errorf("get service ports: %w", err)
+	}
+
+	var conflicting []PortSpec
+	for _, p := range ports {
+		if p.Mode != PortModeHost {
+			continue
+		}
+
+		// Two host ports conflict if they have the same published port number and protocol, and either:
+		//   * At least one host IP is not set (meaning it uses all interfaces)
+		//   * Both host IPs are identical
+		for _, svcPort := range svcPorts {
+			if svcPort.Mode != PortModeHost ||
+				svcPort.PublishedPort != p.PublishedPort ||
+				svcPort.Protocol != p.Protocol {
+				continue
+			}
+
+			if !svcPort.HostIP.IsValid() || !p.HostIP.IsValid() || svcPort.HostIP.Compare(p.HostIP) == 0 {
+				conflicting = append(conflicting, p)
+			}
+		}
+	}
+
+	return conflicting, nil
+}

internal/api/container_test.go

@@ -0,0 +1,346 @@
+package api
+
+import (
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"net/netip"
+	"reflect"
+	"testing"
+)
+
+func TestContainer_ServiceSpec(t *testing.T) {
+	t.Parallel()
+
+	init := true
+	ctr := &Container{ContainerJSON: types.ContainerJSON{
+		ContainerJSONBase: &types.ContainerJSONBase{
+			HostConfig: &container.HostConfig{
+				Binds: []string{"/host/path:/container/path"},
+				Init:  &init,
+			},
+		},
+		Config: &container.Config{
+			Cmd:   []string{"/app/server"},
+			Image: "app:latest",
+			Labels: map[string]string{
+				LabelServiceID:    "test-service-id",
+				LabelServiceName:  "test-service-name",
+				LabelServicePorts: "app.example.com:8000/https",
+			},
+		},
+	}}
+
+	expectedSpec := ServiceSpec{
+		Container: ContainerSpec{
+			Command: []string{"/app/server"},
+			Image:   "app:latest",
+			Init:    &init,
+			Volumes: []string{"/host/path:/container/path"},
+		},
+		Name: "test-service-name",
+		Ports: []PortSpec{
+			{
+				Hostname:      "app.example.com",
+				ContainerPort: 8000,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+	}
+
+	spec, err := ctr.ServiceSpec()
+	require.NoError(t, err)
+	assert.True(t, reflect.DeepEqual(spec, expectedSpec))
+}
+
+func TestContainer_Healthy(t *testing.T) {
+	t.Parallel()
+
+	t.Run("exited", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Running:  false,
+					Dead:     false,
+					ExitCode: 0,
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+
+	t.Run("running with no health check", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Running: true,
+				},
+			},
+		}}
+		assert.True(t, c.Healthy())
+	})
+
+	t.Run("running and healthy", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Running: true,
+					Health: &types.Health{
+						Status: types.Healthy,
+					},
+				},
+			},
+		}}
+		assert.True(t, c.Healthy())
+	})
+
+	t.Run("running but unhealthy", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Running: true,
+					Health: &types.Health{
+						Status: types.Unhealthy,
+					},
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+
+	t.Run("running with health starting", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Running: true,
+					Health: &types.Health{
+						Status: "starting",
+					},
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+
+	t.Run("dead", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Dead:    true,
+					Running: false,
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+
+	t.Run("restarting", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Restarting: true,
+					Running:    true,
+					ExitCode:   1,
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+
+	t.Run("paused", func(t *testing.T) {
+		t.Parallel()
+		c := &Container{ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{
+				State: &types.ContainerState{
+					Paused:  true,
+					Running: true,
+				},
+			},
+		}}
+		assert.False(t, c.Healthy())
+	})
+}
+
+func TestContainer_ConflictingServicePorts(t *testing.T) {
+	tests := []struct {
+		name           string
+		containerPorts string
+		checkPorts     []PortSpec
+		want           []PortSpec
+		wantErr        bool
+	}{
+		{
+			name:           "no conflicts when container has no ports",
+			containerPorts: "",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "host mode ports with same published port and protocol conflict",
+			containerPorts: "8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			want: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			wantErr: false,
+		},
+		{
+			name:           "host mode ports with same port but different protocols don't conflict",
+			containerPorts: "8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolUDP},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "multiple protocols on same port don't conflict",
+			containerPorts: "8080:80/tcp@host,8080:80/udp@host",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolUDP},
+			},
+			want: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolUDP},
+			},
+			wantErr: false,
+		},
+		{
+			name:           "host mode ports with different published ports don't conflict",
+			containerPorts: "8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8081, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "host mode ports with same published port but different host IPs don't conflict",
+			containerPorts: "127.0.0.1:8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.2"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolTCP,
+				},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "host mode ports with same published port, protocol, and host IP conflict",
+			containerPorts: "127.0.0.1:8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.1"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolTCP,
+				},
+			},
+			want: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.1"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolTCP,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:           "host mode port with no host IP conflicts with specific host IP on same port and protocol",
+			containerPorts: "8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.1"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolTCP,
+				},
+			},
+			want: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.1"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolTCP,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:           "host mode port with no host IP doesn't conflict with different protocol",
+			containerPorts: "8080:80/tcp@host",
+			checkPorts: []PortSpec{
+				{
+					Mode:          PortModeHost,
+					HostIP:        netip.MustParseAddr("127.0.0.1"),
+					PublishedPort: 8080,
+					ContainerPort: 80,
+					Protocol:      ProtocolUDP,
+				},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "ingress mode ports don't conflict with host mode ports",
+			containerPorts: "8080:80/tcp",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:           "container with invalid port spec returns error",
+			containerPorts: "invalid:port:spec",
+			checkPorts: []PortSpec{
+				{Mode: PortModeHost, PublishedPort: 8080, ContainerPort: 80, Protocol: ProtocolTCP},
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctr := &Container{ContainerJSON: types.ContainerJSON{
+				Config: &container.Config{
+					Labels: map[string]string{
+						LabelServicePorts: tt.containerPorts,
+					},
+				},
+			}}
+
+			got, err := ctr.ConflictingServicePorts(tt.checkPorts)
+			if tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

internal/api/port.go

@@ -0,0 +1,263 @@
+package api
+
+import (
+	"fmt"
+	"net/netip"
+	"strconv"
+	"strings"
+)
+
+const (
+	PortModeIngress = "ingress"
+	PortModeHost    = "host"
+
+	ProtocolHTTP  = "http"
+	ProtocolHTTPS = "https"
+	ProtocolTCP   = "tcp"
+	ProtocolUDP   = "udp"
+)
+
+type PortSpec struct {
+	// Hostname specifies the DNS name that will route to this service. Only valid in ingress mode.
+	Hostname string
+	// HostIP is the host IP to bind the PublishedPort to. Only valid in host mode.
+	HostIP netip.Addr
+	// PublishedPort is the port number exposed outside the container.
+	// In ingress mode, this is the load balancer port. In host mode, this is the port bound on the host.
+	PublishedPort uint16
+	// ContainerPort is the port inside the container that the service listens on.
+	ContainerPort uint16
+	// Protocol specifies the network protocol.
+	Protocol string
+	// Mode specifies how the port is published.
+	Mode string
+}
+
+func (p *PortSpec) Validate() error {
+	if p.ContainerPort == 0 {
+		return fmt.Errorf("container port must be non-zero")
+	}
+
+	switch p.Protocol {
+	case "":
+		return fmt.Errorf("protocol must be specified")
+	case ProtocolHTTP, ProtocolHTTPS, ProtocolTCP, ProtocolUDP:
+	default:
+		return fmt.Errorf("invalid protocol '%s', supported protocols: '%s', '%s', '%s', '%s'",
+			p.Protocol, ProtocolHTTP, ProtocolHTTPS, ProtocolTCP, ProtocolUDP)
+	}
+
+	switch p.Mode {
+	case "":
+		return fmt.Errorf("mode must be specified")
+	case PortModeIngress:
+		if p.HostIP.IsValid() {
+			return fmt.Errorf("host IP cannot be specified in %s mode", PortModeIngress)
+		}
+		if p.Hostname != "" {
+			if p.Protocol != ProtocolHTTP && p.Protocol != ProtocolHTTPS {
+				return fmt.Errorf("hostname is only valid with '%s' or '%s' protocols", ProtocolHTTP, ProtocolHTTPS)
+			}
+			if err := validateHostname(p.Hostname); err != nil {
+				return fmt.Errorf("invalid hostname '%s': %w", p.Hostname, err)
+			}
+		}
+	case PortModeHost:
+		if p.PublishedPort == 0 {
+			return fmt.Errorf("published port is required in %s mode", PortModeHost)
+		}
+		if p.Protocol != ProtocolTCP && p.Protocol != ProtocolUDP {
+			return fmt.Errorf("unsupported protocol '%s' in %s mode, only '%s' and '%s' are supported",
+				p.Protocol, PortModeHost, ProtocolTCP, ProtocolUDP)
+		}
+		if p.Hostname != "" {
+			return fmt.Errorf("hostname cannot be specified in %s mode", PortModeHost)
+		}
+	default:
+		return fmt.Errorf("invalid mode: '%s'", p.Mode)
+	}
+
+	return nil
+}
+
+// String returns the port specification in the -p/--publish flag format.
+// Format:
+// [hostname:][load_balancer_port:]container_port/protocol for ingress mode (default) or
+// [host_ip:]:host_port:container_port/protocol@host for host mode.
+func (p *PortSpec) String() (string, error) {
+	if err := p.Validate(); err != nil {
+		return "", err
+	}
+
+	var parts []string
+
+	switch p.Mode {
+	case "", PortModeIngress: // [hostname:][load_balancer_port:]container_port/protocol
+		if p.Hostname != "" {
+			parts = append(parts, p.Hostname)
+		}
+		if p.PublishedPort != 0 {
+			parts = append(parts, fmt.Sprint(p.PublishedPort))
+		}
+		parts = append(parts, fmt.Sprint(p.ContainerPort))
+
+		return fmt.Sprintf("%s/%s", strings.Join(parts, ":"), p.Protocol), nil
+	case PortModeHost: // [host_ip:]:host_port:container_port/protocol@host
+		if p.HostIP.IsValid() {
+			if p.HostIP.Is6() {
+				parts = append(parts, fmt.Sprintf("[%s]", p.HostIP))
+			} else {
+				parts = append(parts, p.HostIP.String())
+			}
+		}
+		parts = append(parts, fmt.Sprint(p.PublishedPort))
+		parts = append(parts, fmt.Sprint(p.ContainerPort))
+
+		return fmt.Sprintf("%s/%s@host", strings.Join(parts, ":"), p.Protocol), nil
+	default:
+		return "", fmt.Errorf("not implemented for mode: '%s'", p.Mode)
+	}
+}
+
+func ParsePortSpec(port string) (PortSpec, error) {
+	spec := PortSpec{
+		Protocol: ProtocolTCP,     // Default protocol.
+		Mode:     PortModeIngress, // Default mode.
+	}
+
+	// Split off mode first.
+	parts := strings.Split(port, "@")
+	if len(parts) > 2 {
+		return spec, fmt.Errorf("too many '@' symbols")
+	}
+	if len(parts) == 2 {
+		if parts[1] != PortModeHost {
+			return spec, fmt.Errorf("invalid mode: '%s', only 'host' mode is supported", parts[1])
+		}
+		spec.Mode = PortModeHost
+	}
+	port = parts[0]
+
+	// Parse protocol.
+	parts = strings.Split(port, "/")
+	if len(parts) > 2 {
+		return spec, fmt.Errorf("too many '/' symbols")
+	}
+	specifiedProtocol := ""
+	if len(parts) == 2 {
+		protocol := parts[1]
+		switch protocol {
+		case ProtocolHTTP, ProtocolHTTPS, ProtocolTCP, ProtocolUDP:
+			spec.Protocol = protocol
+			specifiedProtocol = protocol
+		default:
+			return spec, fmt.Errorf("unsupported protocol: '%s'", protocol)
+		}
+	}
+	port = parts[0]
+
+	// Parse hostname/host IP and ports.
+	parts = splitPortParts(port)
+	var err error
+
+	switch len(parts) {
+	case 1: // Just container port.
+		if spec.ContainerPort, err = parsePort(parts[0]); err != nil {
+			return spec, fmt.Errorf("invalid container port '%s': %w", parts[0], err)
+		}
+
+	case 2: // hostname:container_port or [load_balancer_port|host_port]:container_port
+		if spec.ContainerPort, err = parsePort(parts[1]); err != nil {
+			return spec, fmt.Errorf("invalid container port '%s': %w", parts[1], err)
+		}
+
+		if parts[0] == "" {
+			return spec, fmt.Errorf("hostname or published port must be specified, format: " +
+				"hostname:container_port or published_port:container_port")
+		}
+		// Try to parse the first part as port.
+		if publishedPort, err := parsePort(parts[0]); err == nil {
+			spec.PublishedPort = publishedPort
+		} else {
+			// It's a hostname.
+			if spec.Mode == PortModeHost {
+				return spec, fmt.Errorf("hostname cannot be specified in host mode")
+			}
+			spec.Hostname = parts[0]
+		}
+
+	case 3: // hostname:load_balancer_port:container_port or host_ip:host_port:container_port
+		if spec.ContainerPort, err = parsePort(parts[2]); err != nil {
+			return spec, fmt.Errorf("invalid container port '%s': %w", parts[2], err)
+		}
+		if spec.PublishedPort, err = parsePort(parts[1]); err != nil {
+			return spec, fmt.Errorf("invalid published port '%s': %w", parts[1], err)
+		}
+
+		if spec.Mode == PortModeHost {
+			// In host mode, the first part must be IP.
+			ip := parts[0]
+			// Strip brackets from IPv6 address if present.
+			if strings.Contains(ip, ":") {
+				if !strings.HasPrefix(ip, "[") {
+					return spec, fmt.Errorf(
+						"invalid host IP '%s': IPv6 address must be enclosed in square brackets", ip)
+				}
+				if !strings.HasSuffix(ip, "]") {
+					return spec, fmt.Errorf("invalid host IP '%s': missing closing bracket", ip)
+				}
+				ip = ip[1 : len(ip)-1]
+			}
+
+			if spec.HostIP, err = netip.ParseAddr(ip); err != nil {
+				return spec, fmt.Errorf("invalid host IP '%s': %w", parts[0], err)
+			}
+		} else {
+			// Hostname may be empty.
+			spec.Hostname = parts[0]
+		}
+
+	default:
+		return spec, fmt.Errorf("unexpected number of parts in port spec: %d", len(parts))
+	}
+
+	if spec.Hostname != "" {
+		if specifiedProtocol == "" {
+			spec.Protocol = ProtocolHTTPS
+		} else if specifiedProtocol != ProtocolHTTP && specifiedProtocol != ProtocolHTTPS {
+			return spec, fmt.Errorf("hostname is only valid with '%s' or '%s' protocols, specified: '%s'",
+				ProtocolHTTP, ProtocolHTTPS, specifiedProtocol)
+		}
+	}
+
+	return spec, spec.Validate()
+}
+
+// splitPortParts splits a port specification [hostname|host_ip:][published_port:]container_port into its parts.
+func splitPortParts(port string) []string {
+	parts := strings.Split(port, ":")
+	n := len(parts)
+	if n > 3 {
+		// Host IP may contain colons if it's IPv6, so we need to join the first n-2 parts.
+		return append([]string{strings.Join(parts[:n-2], ":")}, parts[n-2:]...)
+	}
+	return parts
+}
+
+func parsePort(s string) (uint16, error) {
+	port, err := strconv.ParseUint(s, 10, 16)
+	if err != nil {
+		return 0, err
+	}
+	return uint16(port), nil
+}
+
+func validateHostname(hostname string) error {
+	if hostname == "" {
+		return fmt.Errorf("must not be empty")
+	}
+	if !strings.Contains(hostname, ".") {
+		return fmt.Errorf("must be a valid domain name containing at least one dot")
+	}
+	return nil
+}

internal/api/port_test.go

@@ -0,0 +1,690 @@
+package api
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"net/netip"
+	"testing"
+)
+
+func TestPortSpec_Validate(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		spec    PortSpec
+		wantErr string
+	}{
+		// Valid ingress mode.
+		{
+			name: "ingress mode tcp",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode with published tcp port",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode udp",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode with published udp port",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode without hostname http",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode without hostname https",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode with hostname and http",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode with hostname and https",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "ingress mode with hostname and published port",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 6443,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+
+		// Valid host mode.
+		{
+			name: "host mode tcp",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode udp",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode with IPv4",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode with IPv6",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("2001:db8::1234:5678"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+		},
+
+		// Error cases.
+		{
+			name: "missing container port",
+			spec: PortSpec{
+				Protocol: ProtocolTCP,
+			},
+			wantErr: "container port must be non-zero",
+		},
+		{
+			name: "invalid protocol",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      "invalid",
+			},
+			wantErr: "invalid protocol 'invalid'",
+		},
+		{
+			name: "invalid mode",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          "invalid",
+			},
+			wantErr: "invalid mode: 'invalid'",
+		},
+		{
+			name: "hostname with non-http protocol",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+			wantErr: "hostname is only valid with 'http' or 'https' protocols",
+		},
+		{
+			name: "invalid hostname",
+			spec: PortSpec{
+				Hostname:      "app",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+			wantErr: "invalid hostname 'app': must be a valid domain name containing at least one dot",
+		},
+		{
+			name: "host IP in ingress mode",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+			wantErr: "host IP cannot be specified in ingress mode",
+		},
+		{
+			name: "zero published port in host mode",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+			wantErr: "published port is required in host mode",
+		},
+		{
+			name: "hostname in host mode",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+			wantErr: "hostname cannot be specified in host mode",
+		},
+		{
+			name: "http in host mode",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeHost,
+			},
+			wantErr: "unsupported protocol 'http' in host mode",
+		},
+		{
+			name: "https in host mode",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeHost,
+			},
+			wantErr: "unsupported protocol 'https' in host mode",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := tt.spec.Validate()
+			if tt.wantErr != "" {
+				require.Error(t, err, tt.wantErr)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestPortSpec_String(t *testing.T) {
+	tests := []struct {
+		name     string
+		spec     PortSpec
+		expected string
+	}{
+		// Ingress mode.
+		{
+			name: "container port only",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+			expected: "8080/tcp",
+		},
+		{
+			name: "container port udp",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeIngress,
+			},
+			expected: "8080/udp",
+		},
+		{
+			name: "published and container port",
+			spec: PortSpec{
+				ContainerPort: 8080,
+				PublishedPort: 80,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+			expected: "80:8080/tcp",
+		},
+		{
+			name: "hostname and container port https",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+			expected: "app.example.com:8080/https",
+		},
+		{
+			name: "hostname and container port http",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+			expected: "app.example.com:8080/http",
+		},
+		{
+			name: "hostname and published and container port https",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 6443,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+			expected: "app.example.com:6443:8080/https",
+		},
+		{
+			name: "hostname and published and container port http",
+			spec: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 6443,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+			expected: "app.example.com:6443:8080/http",
+		},
+
+		// Host mode.
+		{
+			name: "host mode tcp",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+			expected: "80:8080/tcp@host",
+		},
+		{
+			name: "host mode udp",
+			spec: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+			expected: "80:8080/udp@host",
+		},
+		{
+			name: "host mode with IPv4 tcp",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+			expected: "127.0.0.1:80:8080/tcp@host",
+		},
+		{
+			name: "host mode with IPv4 udp",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+			expected: "127.0.0.1:80:8080/udp@host",
+		},
+		{
+			name: "host mode with IPv6",
+			spec: PortSpec{
+				HostIP:        netip.MustParseAddr("2001:db8::1234:5678"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+			expected: "[2001:db8::1234:5678]:80:8080/tcp@host",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := tt.spec.String()
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestParsePortSpec(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		port     string
+		expected PortSpec
+		wantErr  string
+	}{
+		// Ingress mode (default).
+		{
+			name: "container port only",
+			port: "8080",
+			expected: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "published and container port",
+			port: "8000:8080",
+			expected: PortSpec{
+				PublishedPort: 8000,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "published port zero",
+			port: "0:8080",
+			expected: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "tcp protocol explicit",
+			port: "8080/tcp",
+			expected: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "udp protocol",
+			port: "8080/udp",
+			expected: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "published port udp",
+			port: "8000:8080/udp",
+			expected: PortSpec{
+				PublishedPort: 8000,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "hostname and container port",
+			port: "app.example.com:8080",
+			expected: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "container port http without hostname",
+			port: "8080/http",
+			expected: PortSpec{
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "hostname and container port http",
+			port: "app.example.com:8080/http",
+			expected: PortSpec{
+				Hostname:      "app.example.com",
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "hostname and published port",
+			port: "app.example.com:6443:8080",
+			expected: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 6443,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTPS,
+				Mode:          PortModeIngress,
+			},
+		},
+		{
+			name: "hostname and published port http",
+			port: "app.example.com:8000:8080/http",
+			expected: PortSpec{
+				Hostname:      "app.example.com",
+				PublishedPort: 8000,
+				ContainerPort: 8080,
+				Protocol:      ProtocolHTTP,
+				Mode:          PortModeIngress,
+			},
+		},
+
+		// Host mode.
+		{
+			name: "host mode published with protocol",
+			port: "80:8080/udp@host",
+			expected: PortSpec{
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode with IPv4",
+			port: "127.0.0.1:80:8080@host",
+			expected: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode with IPv6",
+			port: "[2001:db8::1234:5678]:80:8080@host",
+			expected: PortSpec{
+				HostIP:        netip.MustParseAddr("2001:db8::1234:5678"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolTCP,
+				Mode:          PortModeHost,
+			},
+		},
+		{
+			name: "host mode with IP and protocol",
+			port: "127.0.0.1:80:8080/udp@host",
+			expected: PortSpec{
+				HostIP:        netip.MustParseAddr("127.0.0.1"),
+				PublishedPort: 80,
+				ContainerPort: 8080,
+				Protocol:      ProtocolUDP,
+				Mode:          PortModeHost,
+			},
+		},
+
+		// Error cases.
+		{
+			name:    "empty",
+			port:    "",
+			wantErr: "invalid container port",
+		},
+		{
+			name:    "invalid container port",
+			port:    "invalid",
+			wantErr: "invalid container port",
+		},
+		{
+			name:    "container port zero",
+			port:    "0",
+			wantErr: "container port must be non-zero",
+		},
+		{
+			name:    "out of range container port",
+			port:    "100500",
+			wantErr: "invalid container port",
+		},
+		{
+			name:    "just protocol",
+			port:    "/tcp",
+			wantErr: "invalid container port",
+		},
+		{
+			name:    "just mode",
+			port:    "@host",
+			wantErr: "invalid container port",
+		},
+		{
+			name:    "multiple @ symbols",
+			port:    "8080@host@host",
+			wantErr: "too many '@' symbols",
+		},
+		{
+			name:    "invalid mode",
+			port:    "8080@invalid",
+			wantErr: "invalid mode: 'invalid'",
+		},
+		{
+			name:    "multiple protocols",
+			port:    "8080/tcp/udp",
+			wantErr: "too many '/' symbols",
+		},
+		{
+			name:    "invalid protocol",
+			port:    "8080/invalid",
+			wantErr: "unsupported protocol: 'invalid'",
+		},
+		{
+			name:    "invalid published port",
+			port:    "app.example.com:invalid:8080",
+			wantErr: "invalid published port",
+		},
+		{
+			name:    "invalid hostname",
+			port:    "app:8080/http",
+			wantErr: "invalid hostname 'app': must be a valid domain name containing at least one dot",
+		},
+		{
+			name:    "hostname with tcp protocol",
+			port:    "app.example.com:8080/tcp",
+			wantErr: "hostname is only valid with 'http' or 'https' protocols",
+		},
+
+		{
+			name:    "missing published port in host mode",
+			port:    "8080@host",
+			wantErr: "published port is required in host mode",
+		},
+		{
+			name:    "missing published port with protocol in host mode",
+			port:    "8080/udp@host",
+			wantErr: "published port is required in host mode",
+		},
+		{
+			name:    "invalid host IPv4",
+			port:    "300.0.0.1:80:8080@host",
+			wantErr: "invalid host IP",
+		},
+		{
+			name:    "invalid host IPv6",
+			port:    "[:::1]:80:8080@host",
+			wantErr: "invalid host IP",
+		},
+		{
+			name:    "missing closing bracket in IPv6",
+			port:    "[::1:80:8080@host",
+			wantErr: "invalid host IP",
+		},
+		{
+			name:    "missing brackets in IPv6",
+			port:    "2001:db8::1234:5678:80:8080@host",
+			wantErr: "invalid host IP",
+		},
+		{
+			name:    "http in host mode",
+			port:    "80:8080/http@host",
+			wantErr: "unsupported protocol 'http' in host mode, only 'tcp' and 'udp' are supported",
+		},
+		{
+			name:    "https in host mode",
+			port:    "80:8080/https@host",
+			wantErr: "unsupported protocol 'https' in host mode, only 'tcp' and 'udp' are supported",
+		},
+		{
+			name:    "hostname in host mode",
+			port:    "app.example.com:8080@host",
+			wantErr: "hostname cannot be specified in host mode",
+		},
+		{
+			name:    "hostname with invalid published port",
+			port:    "app.example.com:invalid:8080@host",
+			wantErr: "invalid published port",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			spec, err := ParsePortSpec(tt.port)
+			if tt.wantErr != "" {
+				require.Error(t, err, "Expected error: %s, got nil, spec: %+v", tt.wantErr, spec)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, spec)
+		})
+	}
+}

internal/api/service.go

@@ -0,0 +1,165 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/distribution/reference"
+	"maps"
+	"reflect"
+	"regexp"
+	"slices"
+	"uncloud/internal/machine/api/pb"
+)
+
+const (
+	ServiceModeReplicated = "replicated"
+	ServiceModeGlobal     = "global"
+)
+
+type ServiceSpec struct {
+	Container ContainerSpec
+	// Mode is the replication mode of the service. Default is ServiceModeReplicated if empty.
+	Mode string
+	Name string
+	// Ports defines what service ports to publish to make the service accessible outside the cluster.
+	Ports []PortSpec
+	// Replicas is the number of containers to run for the service. Only valid for a replicated service.
+	Replicas uint
+}
+
+func (s *ServiceSpec) Validate() error {
+	if err := s.Container.Validate(); err != nil {
+		return err
+	}
+
+	switch s.Mode {
+	case "", ServiceModeGlobal, ServiceModeReplicated:
+	default:
+		return fmt.Errorf("invalid mode: %q", s.Mode)
+	}
+
+	// TODO: validate there is no conflict between ports.
+	// TODO: return error if there are non-HTTP/HTTPS ingress ports that we don't support yet.
+
+	return nil
+}
+
+// Equals returns true if the service spec is equal to the given spec ignoring the number of replicas.
+func (s *ServiceSpec) Equals(spec ServiceSpec) bool {
+	// TODO: ignore order of ports.
+	sCopy := *s
+	// Ignore the number of replicas when comparing.
+	sCopy.Replicas = 0
+	spec.Replicas = 0
+	return reflect.DeepEqual(*s, spec)
+}
+
+var serviceIDRegexp = regexp.MustCompile("^[0-9a-f]{32}$")
+
+func ValidateServiceID(id string) bool {
+	return serviceIDRegexp.MatchString(id)
+}
+
+type ContainerSpec struct {
+	Command []string
+	Image   string
+	// Run a custom init inside the container. If nil, use the daemon's configured settings.
+	Init *bool
+	// List of volumes to bind mount into the container.
+	Volumes []string
+}
+
+func (s *ContainerSpec) Validate() error {
+	if _, err := reference.ParseDockerRef(s.Image); err != nil {
+		return fmt.Errorf("invalid image: %w", err)
+	}
+
+	return nil
+}
+
+type Service struct {
+	ID         string
+	Name       string
+	Mode       string
+	Containers []MachineContainer
+}
+
+type MachineContainer struct {
+	MachineID string
+	Container Container
+}
+
+// Endpoints returns the exposed HTTP and HTTPS endpoints of the service.
+func (s *Service) Endpoints() []string {
+	endpoints := make(map[string]struct{})
+
+	// Container specs may differ between containers in the same service, e.g. during a rolling update,
+	// so we need to collect all unique endpoints.
+	for _, ctr := range s.Containers {
+		ports, err := ctr.Container.ServicePorts()
+		if err != nil {
+			continue
+		}
+
+		for _, port := range ports {
+			protocol := ""
+			switch port.Protocol {
+			case ProtocolHTTP:
+				protocol = "http"
+			case ProtocolHTTPS:
+				protocol = "https"
+			default:
+				continue
+			}
+
+			if port.Hostname == "" {
+				// There shouldn't be http(s) ports without a hostname but just in case ignore them.
+				continue
+			}
+
+			endpoint := fmt.Sprintf("%s://%s", protocol, port.Hostname)
+			if port.PublishedPort != 0 {
+				// For non-standard ports (80/443), include the port in the URL.
+				if !(port.Protocol == ProtocolHTTP && port.PublishedPort == 80) &&
+					!(port.Protocol == ProtocolHTTPS && port.PublishedPort == 443) {
+					endpoint += fmt.Sprintf(":%d", port.PublishedPort)
+				}
+			}
+
+			endpoint += fmt.Sprintf(" → :%d", port.ContainerPort)
+			endpoints[endpoint] = struct{}{}
+		}
+	}
+
+	return slices.Sorted(maps.Keys(endpoints))
+}
+
+func ServiceFromProto(s *pb.Service) (Service, error) {
+	var err error
+	containers := make([]MachineContainer, len(s.Containers))
+	for i, sc := range s.Containers {
+		containers[i], err = machineContainerFromProto(sc)
+		if err != nil {
+			return Service{}, err
+		}
+	}
+
+	return Service{
+		ID:         s.Id,
+		Name:       s.Name,
+		Mode:       s.Mode,
+		Containers: containers,
+	}, nil
+}
+
+func machineContainerFromProto(sc *pb.Service_Container) (MachineContainer, error) {
+	var c Container
+	if err := json.Unmarshal(sc.Container, &c); err != nil {
+		return MachineContainer{}, fmt.Errorf("unmarshal container: %w", err)
+	}
+
+	return MachineContainer{
+		MachineID: sc.MachineId,
+		Container: c,
+	}, nil
+}

internal/cli/cli.go

@@ -4,27 +4,23 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/charmbracelet/huh"
-	"google.golang.org/protobuf/types/known/emptypb"
+	"github.com/docker/cli/cli/streams"
 	"net/netip"
 	"os"
-	"strings"
-	"text/tabwriter"
 	"uncloud/internal/cli/client"
 	"uncloud/internal/cli/client/connector"
 	"uncloud/internal/cli/config"
+	"uncloud/internal/fs"
 	"uncloud/internal/machine"
 	"uncloud/internal/machine/api/pb"
-	"uncloud/internal/secret"
 	"uncloud/internal/sshexec"
+
+	"github.com/charmbracelet/huh"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 const defaultClusterName = "default"
 
-var (
-	ErrNotFound = errors.New("not found")
-)
-
 type CLI struct {
 	config *config.Config
 }
@@ -39,35 +35,19 @@ func New(configPath string) (*CLI, error) {
 	}, nil
 }
 
-func (cli *CLI) CreateCluster(name string, userPrivateKey secret.Secret) error {
+func (cli *CLI) CreateCluster(name string) error {
 	if _, ok := cli.config.Clusters[name]; ok {
 		return fmt.Errorf("cluster %q already exists", name)
 	}
-	if userPrivateKey == nil {
-		user, err := client.NewUser(nil)
-		if err != nil {
-			return fmt.Errorf("generate user: %w", err)
-		}
-		userPrivateKey = user.PrivateKey()
-	}
-
 	cli.config.Clusters[name] = &config.Cluster{
-		Name:           name,
-		UserPrivateKey: userPrivateKey,
+		Name: name,
 	}
 	return cli.config.Save()
 }
 
-func (cli *CLI) CreateDefaultCluster() error {
-	if err := cli.CreateCluster(defaultClusterName, nil); err != nil {
-		return err
-	}
-	return cli.SetCurrentCluster(defaultClusterName)
-}
-
 func (cli *CLI) SetCurrentCluster(name string) error {
 	if _, ok := cli.config.Clusters[name]; !ok {
-		return ErrNotFound
+		return client.ErrNotFound
 	}
 	cli.config.CurrentCluster = name
 	return cli.config.Save()
@@ -108,158 +88,161 @@ func (cli *CLI) ConnectCluster(ctx context.Context, clusterName string) (*client
 
 	// TODO: iterate over all connections and try to connect to the cluster using the first successful connection.
 	conn := cfg.Connections[0]
-	user, host, port, err := conn.SSH.Parse()
-	if err != nil {
-		return nil, fmt.Errorf("parse SSH connection %q: %w", conn.SSH, err)
+	if conn.SSH != "" {
+		user, host, port, err := conn.SSH.Parse()
+		if err != nil {
+			return nil, fmt.Errorf("parse SSH connection %q: %w", conn.SSH, err)
+		}
+
+		keyPath := fs.ExpandHomeDir(conn.SSHKeyFile)
+
+		sshConfig := &connector.SSHConnectorConfig{
+			User:    user,
+			Host:    host,
+			Port:    port,
+			KeyPath: keyPath,
+		}
+		return client.New(ctx, connector.NewSSHConnector(sshConfig))
+	} else if conn.TCP.IsValid() {
+		return client.New(ctx, connector.NewTCPConnector(conn.TCP))
 	}
-	sshConfig := &connector.SSHConnectorConfig{
-		User: user,
-		Host: host,
-		Port: port,
-	}
-	return client.New(ctx, connector.NewSSHConnector(sshConfig))
+	return nil, errors.New("no valid connection configuration found for the cluster")
 }
 
+// InitCluster initialises a new cluster on a remote machine and returns a client to interact with the cluster.
+// The client should be closed after use by the caller.
 func (cli *CLI) InitCluster(
-	ctx context.Context, remoteMachine *RemoteMachine, clusterName, machineName string, netPrefix netip.Prefix,
-) error {
+	ctx context.Context,
+	remoteMachine *RemoteMachine,
+	clusterName,
+	machineName string,
+	netPrefix netip.Prefix,
+	publicIP *netip.Addr,
+) (*client.Client, error) {
 	if remoteMachine != nil {
-		return cli.initRemoteMachine(ctx, *remoteMachine, clusterName, machineName, netPrefix)
+		return cli.initRemoteMachine(ctx, *remoteMachine, clusterName, machineName, netPrefix, publicIP)
 	}
 	// TODO: implement local machine initialisation
-	return fmt.Errorf("local machine initialisation is not implemented yet")
+	return nil, fmt.Errorf("local machine initialisation is not implemented yet")
 }
 
 func (cli *CLI) initRemoteMachine(
-	ctx context.Context, remoteMachine RemoteMachine, clusterName, machineName string, netPrefix netip.Prefix,
-) error {
+	ctx context.Context,
+	remoteMachine RemoteMachine,
+	clusterName,
+	machineName string,
+	netPrefix netip.Prefix,
+	publicIP *netip.Addr,
+) (*client.Client, error) {
 	if clusterName == "" {
 		clusterName = defaultClusterName
 	}
 	if _, ok := cli.config.Clusters[clusterName]; ok {
-		return fmt.Errorf("cluster %q already exists", clusterName)
-	}
-	user, err := client.NewUser(nil)
-	if err != nil {
-		return fmt.Errorf("generate cluster user: %w", err)
+		return nil, fmt.Errorf("cluster %q already exists", clusterName)
 	}
 
-	// Provision the remote machine by installing the Uncloud daemon and dependencies over SSH.
-	sshClient, err := sshexec.Connect(remoteMachine.User, remoteMachine.Host, remoteMachine.Port, remoteMachine.KeyPath)
+	machineClient, err := cli.provisionRemoteMachine(ctx, remoteMachine)
 	if err != nil {
-		return fmt.Errorf(
-			"SSH login to remote machine %s: %w",
-			config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port), err,
-		)
+		return nil, err
 	}
-	exec := sshexec.NewRemote(sshClient)
-	// Install and run the Uncloud daemon and dependencies on the remote machine.
-	if err = provisionMachine(ctx, exec); err != nil {
-		return fmt.Errorf("provision machine: %w", err)
-	}
-
-	// Create a machine API client over the SSH connection to the remote machine.
-	machineClient, err := client.New(ctx, connector.NewSSHConnectorFromClient(sshClient))
-	if err != nil {
-		return fmt.Errorf("connect to remote machine: %w", err)
-	}
-	defer machineClient.Close()
+	// Ensure machineClient is closed on error.
+	defer func() {
+		if err != nil {
+			machineClient.Close()
+		}
+	}()
 
 	// Check if the machine is already initialised as a cluster member and prompt the user to reset it first.
 	minfo, err := machineClient.Inspect(ctx, &emptypb.Empty{})
 	if err != nil {
-		return fmt.Errorf("inspect machine: %w", err)
+		return nil, fmt.Errorf("inspect machine: %w", err)
 	}
 	if minfo.Id != "" {
 		if err = cli.promptResetMachine(); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	req := &pb.InitClusterRequest{
 		MachineName: machineName,
 		Network:     pb.NewIPPrefix(netPrefix),
-		User: &pb.User{
-			Network: &pb.NetworkConfig{
-				ManagementIp: pb.NewIP(user.ManagementIP()),
-				PublicKey:    user.PublicKey(),
-			},
-		},
 	}
+	if publicIP != nil {
+		if publicIP.IsValid() {
+			req.PublicIpConfig = &pb.InitClusterRequest_PublicIp{PublicIp: pb.NewIP(*publicIP)}
+		} else {
+			// Invalid or in other words zero IP means to automatically detect the public IP.
+			req.PublicIpConfig = &pb.InitClusterRequest_PublicIpAuto{PublicIpAuto: true}
+		}
+	}
+
 	resp, err := machineClient.InitCluster(ctx, req)
 	if err != nil {
-		return fmt.Errorf("init cluster: %w", err)
+		return nil, fmt.Errorf("init cluster: %w", err)
 	}
 	fmt.Printf("Cluster %q initialised with machine %q\n", clusterName, resp.Machine.Name)
 
-	if err = cli.CreateCluster(clusterName, user.PrivateKey()); err != nil {
-		return fmt.Errorf("save cluster to config: %w", err)
+	if err = cli.CreateCluster(clusterName); err != nil {
+		return nil, fmt.Errorf("save cluster to config: %w", err)
 	}
 	// Set the current cluster to the just created one if it is the only cluster in the config.
 	if len(cli.config.Clusters) == 1 {
 		if err = cli.SetCurrentCluster(clusterName); err != nil {
-			return fmt.Errorf("set current cluster: %w", err)
+			return nil, fmt.Errorf("set current cluster: %w", err)
 		}
 	}
+
 	// Save the machine's SSH connection details in the cluster config.
 	connCfg := config.MachineConnection{
-		SSH: config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port),
+		SSH:        config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port),
+		SSHKeyFile: remoteMachine.KeyPath,
 	}
 	cli.config.Clusters[clusterName].Connections = append(cli.config.Clusters[clusterName].Connections, connCfg)
 	if err = cli.config.Save(); err != nil {
-		return fmt.Errorf("save config: %w", err)
+		return nil, fmt.Errorf("save config: %w", err)
 	}
-	return nil
+	return machineClient, nil
 }
 
-func (cli *CLI) AddMachine(ctx context.Context, remoteMachine RemoteMachine, clusterName, machineName string) error {
+// AddMachine provisions a remote machine and adds it to the cluster. It returns a client to interact with the machine
+// which should be closed after use by the caller.
+func (cli *CLI) AddMachine(
+	ctx context.Context, remoteMachine RemoteMachine, clusterName, machineName string, publicIP *netip.Addr,
+) (*client.Client, error) {
 	c, err := cli.ConnectCluster(ctx, clusterName)
 	if err != nil {
-		return fmt.Errorf("connect to cluster: %w", err)
+		return nil, fmt.Errorf("connect to cluster: %w", err)
+	}
+	defer c.Close()
+
+	machineClient, err := cli.provisionRemoteMachine(ctx, remoteMachine)
+	if err != nil {
+		return nil, err
 	}
 	defer func() {
-		_ = c.Close()
+		if err != nil {
+			machineClient.Close()
+		}
 	}()
 
-	// Provision the remote machine by installing the Uncloud daemon and dependencies over SSH.
-	sshClient, err := sshexec.Connect(remoteMachine.User, remoteMachine.Host, remoteMachine.Port, remoteMachine.KeyPath)
-	if err != nil {
-		return fmt.Errorf(
-			"SSH login to remote machine %s: %w",
-			config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port), err,
-		)
-	}
-	exec := sshexec.NewRemote(sshClient)
-	// Install and run the Uncloud daemon and dependencies on the remote machine.
-	if err = provisionMachine(ctx, exec); err != nil {
-		return fmt.Errorf("provision machine: %w", err)
-	}
-
-	// Create a machine API client over the SSH connection to the remote machine.
-	machineClient, err := client.New(ctx, connector.NewSSHConnectorFromClient(sshClient))
-	if err != nil {
-		return fmt.Errorf("connect to remote machine: %w", err)
-	}
-	defer machineClient.Close()
-
 	// Check if the machine is already initialised as a cluster member and prompt the user to reset it first.
 	minfo, err := machineClient.Inspect(ctx, &emptypb.Empty{})
 	if err != nil {
-		return fmt.Errorf("inspect machine: %w", err)
+		return nil, fmt.Errorf("inspect machine: %w", err)
 	}
 	if minfo.Id != "" {
 		if err = cli.promptResetMachine(); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	tokenResp, err := machineClient.Token(ctx, &emptypb.Empty{})
 	if err != nil {
-		return fmt.Errorf("get remote machine token: %w", err)
+		return nil, fmt.Errorf("get remote machine token: %w", err)
 	}
 	token, err := machine.ParseToken(tokenResp.Token)
 	if err != nil {
-		return fmt.Errorf("parse remote machine token: %w", err)
+		return nil, fmt.Errorf("parse remote machine token: %w", err)
 	}
 
 	// Register the machine in the cluster using its public key and endpoints from the token.
@@ -274,20 +257,29 @@ func (cli *CLI) AddMachine(ctx context.Context, remoteMachine RemoteMachine, clu
 			PublicKey: token.PublicKey,
 		},
 	}
+	if publicIP != nil {
+		if publicIP.IsValid() {
+			addReq.PublicIp = pb.NewIP(*publicIP)
+		} else if token.PublicIP.IsValid() {
+			// Invalid or in other words zero IP means to use an automatically detected public IP from the token.
+			addReq.PublicIp = pb.NewIP(token.PublicIP)
+		}
+	}
+
 	addResp, err := c.AddMachine(ctx, addReq)
 	if err != nil {
-		return fmt.Errorf("add machine to cluster: %w", err)
+		return nil, fmt.Errorf("add machine to cluster: %w", err)
 	}
 
 	// List other machines in the cluster to include them in the join request.
-	listResp, err := c.ListMachines(ctx, &emptypb.Empty{})
+	machines, err := c.ListMachines(ctx)
 	if err != nil {
-		return fmt.Errorf("list cluster machines: %w", err)
+		return nil, fmt.Errorf("list cluster machines: %w", err)
 	}
-	otherMachines := make([]*pb.MachineInfo, 0, len(listResp.Machines)-1)
-	for _, m := range listResp.Machines {
-		if m.Id != addResp.Machine.Id {
-			otherMachines = append(otherMachines, m)
+	otherMachines := make([]*pb.MachineInfo, 0, len(machines)-1)
+	for _, m := range machines {
+		if m.Machine.Id != addResp.Machine.Id {
+			otherMachines = append(otherMachines, m.Machine)
 		}
 	}
 
@@ -297,24 +289,63 @@ func (cli *CLI) AddMachine(ctx context.Context, remoteMachine RemoteMachine, clu
 		OtherMachines: otherMachines,
 	}
 	if _, err = machineClient.JoinCluster(ctx, joinReq); err != nil {
-		return fmt.Errorf("join cluster: %w", err)
+		return nil, fmt.Errorf("join cluster: %w", err)
 	}
 
 	fmt.Printf("Machine %q added to cluster\n", addResp.Machine.Name)
 
 	// Save the machine's SSH connection details in the cluster config.
 	connCfg := config.MachineConnection{
-		SSH: config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port),
+		SSH:        config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port),
+		SSHKeyFile: remoteMachine.KeyPath,
 	}
 	if clusterName == "" {
 		clusterName = cli.config.CurrentCluster
 	}
 	cli.config.Clusters[clusterName].Connections = append(cli.config.Clusters[clusterName].Connections, connCfg)
 	if err = cli.config.Save(); err != nil {
-		return fmt.Errorf("save config: %w", err)
+		return nil, fmt.Errorf("save config: %w", err)
 	}
 
-	return nil
+	return machineClient, nil
+}
+
+// provisionRemoteMachine installs the Uncloud daemon and dependencies on the remote machine over SSH and returns
+// a machine API client to interact with the machine. The client should be closed after use by the caller.
+func (cli *CLI) provisionRemoteMachine(ctx context.Context, remoteMachine RemoteMachine) (*client.Client, error) {
+	// Provision the remote machine by installing the Uncloud daemon and dependencies over SSH.
+	sshClient, err := sshexec.Connect(remoteMachine.User, remoteMachine.Host, remoteMachine.Port, remoteMachine.KeyPath)
+	if err != nil {
+		return nil, fmt.Errorf(
+			"SSH login to remote machine %s: %w",
+			config.NewSSHDestination(remoteMachine.User, remoteMachine.Host, remoteMachine.Port), err,
+		)
+	}
+	exec := sshexec.NewRemote(sshClient)
+	// Install and run the Uncloud daemon and dependencies on the remote machine.
+	if err = provisionMachine(ctx, exec); err != nil {
+		return nil, fmt.Errorf("provision machine: %w", err)
+	}
+
+	var machineClient *client.Client
+	if remoteMachine.User == "root" {
+		// Create a machine API client over the established SSH connection to the remote machine.
+		machineClient, err = client.New(ctx, connector.NewSSHConnectorFromClient(sshClient))
+	} else {
+		// Since the user is not root, we need to establish a new SSH connection to make the user's addition
+		// to the uncloud group effective, thus allowing access to the Uncloud daemon Unix socket.
+		sshConfig := &connector.SSHConnectorConfig{
+			User:    remoteMachine.User,
+			Host:    remoteMachine.Host,
+			Port:    remoteMachine.Port,
+			KeyPath: remoteMachine.KeyPath,
+		}
+		machineClient, err = client.New(ctx, connector.NewSSHConnector(sshConfig))
+	}
+	if err != nil {
+		return nil, fmt.Errorf("connect to remote machine: %w", err)
+	}
+	return machineClient, nil
 }
 
 func (cli *CLI) promptResetMachine() error {
@@ -341,41 +372,7 @@ func (cli *CLI) promptResetMachine() error {
 	return fmt.Errorf("resetting the remote machine is not implemented yet")
 }
 
-func (cli *CLI) ListMachines(ctx context.Context, clusterName string) error {
-	c, err := cli.ConnectCluster(ctx, clusterName)
-	if err != nil {
-		return fmt.Errorf("connect to cluster: %w", err)
-	}
-	defer func() {
-		_ = c.Close()
-	}()
-
-	listResp, err := c.ListMachines(ctx, &emptypb.Empty{})
-	if err != nil {
-		return fmt.Errorf("list machines: %w", err)
-	}
-
-	// Print the list of machines in a table format.
-	tw := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
-	// Print header.
-	// TODO: print ADDRESS instead of SUBNET which is a machine IP with prefix.
-	if _, err = fmt.Fprintln(tw, "NAME\tSUBNET\tPUBLIC KEY\tENDPOINTS"); err != nil {
-		return fmt.Errorf("write header: %w", err)
-	}
-	// Print rows.
-	for _, m := range listResp.Machines {
-		subnet, _ := m.Network.Subnet.ToPrefix()
-		endpoints := make([]string, len(m.Network.Endpoints))
-		for i, ep := range m.Network.Endpoints {
-			addrPort, _ := ep.ToAddrPort()
-			endpoints[i] = addrPort.String()
-		}
-		publicKey := secret.Secret(m.Network.PublicKey)
-		if _, err = fmt.Fprintf(
-			tw, "%s\t%s\t%s\t%s\n", m.Name, subnet, publicKey, strings.Join(endpoints, ", "),
-		); err != nil {
-			return fmt.Errorf("write row: %w", err)
-		}
-	}
-	return tw.Flush()
+// ProgressOut returns an output stream for progress writer.
+func (cli *CLI) ProgressOut() *streams.Out {
+	return streams.NewOut(os.Stdout)
 }

internal/cli/client/caddy.go

@@ -0,0 +1,102 @@
+package client
+
+import (
+	"fmt"
+	"github.com/Masterminds/semver"
+	"github.com/distribution/reference"
+	"github.com/google/go-containerregistry/pkg/name"
+	"github.com/google/go-containerregistry/pkg/v1/remote"
+	"regexp"
+	"uncloud/internal/api"
+)
+
+const (
+	CaddyServiceName = "caddy"
+	// CaddyImage is the official Caddy Docker image on Docker Hub: https://hub.docker.com/_/caddy
+	CaddyImage = "caddy"
+)
+
+var caddyImageTagRegex = regexp.MustCompile(`^2\.\d+\.\d+$`)
+
+// NewCaddyDeployment creates a new deployment for a Caddy reverse proxy service.
+// The service is deployed in global mode to all machines in the cluster. If the image is not provided, the latest
+// version of the official Caddy Docker image is used.
+func (cli *Client) NewCaddyDeployment(image string, filter MachineFilter) (*Deployment, error) {
+	latest, err := latestCaddyImage()
+	if err != nil {
+		return nil, fmt.Errorf("look up latest Caddy image: %w", err)
+	}
+
+	if image == "" {
+		image = reference.FamiliarString(latest)
+	}
+
+	// TODO: set restart policy to always. https://github.com/psviderski/uncloud/issues/26
+	spec := api.ServiceSpec{
+		Container: api.ContainerSpec{
+			Command: []string{"caddy", "run", "-c", "/config/caddy.json", "--watch"},
+			Image:   image,
+			Volumes: []string{"/var/lib/uncloud/caddy:/config"},
+		},
+		Mode: api.ServiceModeGlobal,
+		Name: CaddyServiceName,
+		Ports: []api.PortSpec{
+			{
+				PublishedPort: 80,
+				ContainerPort: 80,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+			{
+				PublishedPort: 443,
+				ContainerPort: 443,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+		},
+	}
+
+	return cli.NewDeployment(spec, &RollingStrategy{MachineFilter: filter})
+}
+
+// latestCaddyImage returns the latest image of the official Caddy Docker image on Docker Hub.
+// The latest image is determined by the latest version tag 2.x.x.
+func latestCaddyImage() (reference.NamedTagged, error) {
+	repo, err := name.NewRepository(CaddyImage)
+	if err != nil {
+		return nil, fmt.Errorf("parse image: %w", err)
+	}
+	tags, err := remote.List(repo)
+	if err != nil {
+		return nil, fmt.Errorf("list image tags: %w", err)
+	}
+
+	// Default to the 'latest' tag but try to find the latest version tag 2.x.x.
+	latestTag := "latest"
+	var latestVersion *semver.Version
+	for _, t := range tags {
+		if !caddyImageTagRegex.MatchString(t) {
+			continue
+		}
+
+		v, err := semver.NewVersion(t)
+		if err != nil {
+			continue
+		}
+		if latestVersion == nil || v.GreaterThan(latestVersion) {
+			latestVersion = v
+			latestTag = t
+		}
+	}
+
+	image, err := reference.ParseDockerRef(CaddyImage)
+	if err != nil {
+		return nil, fmt.Errorf("parse image: %w", err)
+	}
+	imageWithTag, err := reference.WithTag(image, latestTag)
+	if err != nil {
+		return nil, fmt.Errorf("set image tag: %w", err)
+	}
+
+	return imageWithTag, nil
+}

internal/cli/client/caddy_test.go

@@ -0,0 +1,69 @@
+package client
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"uncloud/internal/api"
+)
+
+func TestClient_NewCaddyDeployment(t *testing.T) {
+	t.Parallel()
+
+	cli := &Client{}
+
+	t.Run("latest image from Docker Hub", func(t *testing.T) {
+		t.Parallel()
+
+		deploy, err := cli.NewCaddyDeployment("", nil)
+		require.NoError(t, err)
+
+		assert.Equal(t, "caddy", deploy.Spec.Name)
+		assert.Equal(t, api.ServiceModeGlobal, deploy.Spec.Mode)
+		assert.Regexp(t, `^caddy:2\.\d+\.\d+$`, deploy.Spec.Container.Image)
+		expectedPorts := []api.PortSpec{
+			{
+				PublishedPort: 80,
+				ContainerPort: 80,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+			{
+				PublishedPort: 443,
+				ContainerPort: 443,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+		}
+		assert.Equal(t, expectedPorts, deploy.Spec.Ports)
+		// TODO:
+		//assert.Equal(t, alwaysPullImage, deploy.Spec.Container.PullPolicy)
+	})
+
+	t.Run("custom image", func(t *testing.T) {
+		t.Parallel()
+
+		image := "my-caddy:1.2.3"
+		deploy, err := cli.NewCaddyDeployment(image, nil)
+		require.NoError(t, err)
+
+		assert.Equal(t, "caddy", deploy.Spec.Name)
+		assert.Equal(t, api.ServiceModeGlobal, deploy.Spec.Mode)
+		assert.Equal(t, image, deploy.Spec.Container.Image)
+		expectedPorts := []api.PortSpec{
+			{
+				PublishedPort: 80,
+				ContainerPort: 80,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+			{
+				PublishedPort: 443,
+				ContainerPort: 443,
+				Protocol:      api.ProtocolTCP,
+				Mode:          api.PortModeHost,
+			},
+		}
+		assert.Equal(t, expectedPorts, deploy.Spec.Ports)
+	})
+}

internal/cli/client/client.go

@@ -4,10 +4,16 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/docker/cli/cli/streams"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+	"os"
 	"uncloud/internal/machine/api/pb"
+	"uncloud/internal/machine/docker"
 )
 
+var ErrNotFound = errors.New("not found")
+
 // Client is a client for the machine API.
 type Client struct {
 	connector Connector
@@ -15,6 +21,9 @@ type Client struct {
 
 	pb.MachineClient
 	pb.ClusterClient
+	// Docker is a namespaced client for the Docker service to distinguish Uncloud-specific service container operations
+	// from generic Docker operations.
+	Docker *docker.Client
 }
 
 // Connector is an interface for establishing a connection to the machine API.
@@ -37,10 +46,22 @@ func New(ctx context.Context, connector Connector) (*Client, error) {
 
 	c.MachineClient = pb.NewMachineClient(c.conn)
 	c.ClusterClient = pb.NewClusterClient(c.conn)
+	c.Docker = docker.NewClient(c.conn)
 	return c, nil
 }
 
-func (c *Client) Close() error {
-	err := c.conn.Close()
-	return errors.Join(err, c.connector.Close())
+func (cli *Client) Close() error {
+	return errors.Join(cli.conn.Close(), cli.connector.Close())
+}
+
+// progressOut returns an output stream for progress writer.
+func (cli *Client) progressOut() *streams.Out {
+	return streams.NewOut(os.Stdout)
+}
+
+// proxyToMachine returns a new context that proxies gRPC requests to the specified machine.
+func proxyToMachine(ctx context.Context, machine *pb.MachineInfo) context.Context {
+	machineIP, _ := machine.Network.ManagementIp.ToAddr()
+	md := metadata.Pairs("machines", machineIP.String())
+	return metadata.NewOutgoingContext(ctx, md)
 }

internal/cli/client/cluster.go

@@ -0,0 +1,30 @@
+package client
+
+import (
+	"context"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"uncloud/internal/machine/api/pb"
+)
+
+func (cli *Client) InspectMachine(ctx context.Context, id string) (*pb.MachineMember, error) {
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, m := range machines {
+		if m.Machine.Id == id || m.Machine.Name == id {
+			return m, nil
+		}
+	}
+
+	return nil, ErrNotFound
+}
+
+func (cli *Client) ListMachines(ctx context.Context) ([]*pb.MachineMember, error) {
+	resp, err := cli.ClusterClient.ListMachines(ctx, &emptypb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	return resp.Machines, nil
+}

internal/cli/client/connector/ssh.go

@@ -18,7 +18,7 @@ type SSHConnectorConfig struct {
 	Port    int
 	KeyPath string
 
-	APISockPath string
+	SockPath string
 }
 
 // SSHConnector establishes a connection to the machine API through an SSH tunnel to the machine.
@@ -49,12 +49,12 @@ func (c *SSHConnector) Connect(ctx context.Context) (*grpc.ClientConn, error) {
 		}
 	}
 
-	apiSockPath := c.config.APISockPath
-	if apiSockPath == "" {
-		apiSockPath = machine.DefaultAPISockPath
+	sockPath := c.config.SockPath
+	if sockPath == "" {
+		sockPath = machine.DefaultUncloudSockPath
 	}
 	conn, err := grpc.NewClient(
-		"unix://"+apiSockPath,
+		"unix://"+sockPath,
 		grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithContextDialer(
 			func(ctx context.Context, addr string) (net.Conn, error) {

internal/cli/client/connector/tcp.go

@@ -0,0 +1,33 @@
+package connector
+
+import (
+	"context"
+	"fmt"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"net/netip"
+)
+
+// TCPConnector establishes a connection to the machine API through a direct TCP connection to an API endpoint.
+type TCPConnector struct {
+	apiAddr netip.AddrPort
+}
+
+func NewTCPConnector(apiAddr netip.AddrPort) *TCPConnector {
+	return &TCPConnector{apiAddr: apiAddr}
+}
+
+func (c *TCPConnector) Connect(_ context.Context) (*grpc.ClientConn, error) {
+	conn, err := grpc.NewClient(
+		c.apiAddr.String(),
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("create machine API client: %w", err)
+	}
+	return conn, nil
+}
+
+func (c *TCPConnector) Close() error {
+	return nil
+}

internal/cli/client/container.go

@@ -0,0 +1,335 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/docker/compose/v2/pkg/progress"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	dockerclient "github.com/docker/docker/client"
+	"github.com/docker/docker/pkg/jsonmessage"
+	"github.com/docker/go-connections/nat"
+	"google.golang.org/grpc/status"
+	"strconv"
+	"strings"
+	"uncloud/internal/api"
+	machinedocker "uncloud/internal/machine/docker"
+	"uncloud/internal/secret"
+)
+
+// CreateContainer creates a new container for the given service on the specified machine.
+func (cli *Client) CreateContainer(
+	ctx context.Context, serviceID string, spec api.ServiceSpec, machineID string,
+) (container.CreateResponse, error) {
+	var resp container.CreateResponse
+
+	if !api.ValidateServiceID(serviceID) {
+		return resp, fmt.Errorf("invalid service ID: '%s'", serviceID)
+	}
+	// TODO: validate spec.Name is consistent with serviceID if this is not the first container in the service.
+
+	machine, err := cli.InspectMachine(ctx, machineID)
+	if err != nil {
+		return resp, fmt.Errorf("inspect machine '%s': %w", machineID, err)
+	}
+
+	suffix, err := secret.RandomAlphaNumeric(4)
+	if err != nil {
+		return resp, fmt.Errorf("generate random suffix: %w", err)
+	}
+	containerName := fmt.Sprintf("%s-%s", spec.Name, suffix)
+
+	config := &container.Config{
+		Cmd:      spec.Container.Command,
+		Hostname: containerName,
+		Image:    spec.Container.Image,
+		Labels: map[string]string{
+			api.LabelServiceID:   serviceID,
+			api.LabelServiceName: spec.Name,
+			api.LabelServiceMode: spec.Mode,
+			api.LabelManaged:     "",
+		},
+	}
+	if spec.Mode == "" {
+		config.Labels[api.LabelServiceMode] = api.ServiceModeReplicated
+	}
+
+	if len(spec.Ports) > 0 {
+		encodedPorts := make([]string, len(spec.Ports))
+		for i, p := range spec.Ports {
+			encodedPorts[i], err = p.String()
+			if err != nil {
+				return resp, fmt.Errorf("encode service port spec: %w", err)
+			}
+		}
+
+		config.Labels[api.LabelServicePorts] = strings.Join(encodedPorts, ",")
+	}
+
+	portBindings := make(nat.PortMap)
+	for _, p := range spec.Ports {
+		if p.Mode != api.PortModeHost {
+			continue
+		}
+		port := nat.Port(fmt.Sprintf("%d/%s", p.ContainerPort, p.Protocol))
+		portBindings[port] = []nat.PortBinding{
+			{
+				HostPort: strconv.Itoa(int(p.PublishedPort)),
+			},
+		}
+		if p.HostIP.IsValid() {
+			portBindings[port][0].HostIP = p.HostIP.String()
+		}
+	}
+	hostConfig := &container.HostConfig{
+		Binds:        spec.Container.Volumes,
+		Init:         spec.Container.Init,
+		PortBindings: portBindings,
+		// Always restart service containers if they exit or a machine restarts.
+		// For one-off containers and batch jobs we plan to use a different service type/mode.
+		RestartPolicy: container.RestartPolicy{
+			Name: container.RestartPolicyAlways,
+		},
+	}
+	netConfig := &network.NetworkingConfig{
+		EndpointsConfig: map[string]*network.EndpointSettings{
+			machinedocker.NetworkName: {},
+		},
+	}
+
+	// Proxy Docker gRPC requests to the selected machine.
+	ctx = proxyToMachine(ctx, machine.Machine)
+
+	pw := progress.ContextWriter(ctx)
+	eventID := fmt.Sprintf("Container %s on %s", containerName, machine.Machine.Name)
+
+	pw.Event(progress.CreatingEvent(eventID))
+	resp, err = cli.Docker.CreateContainer(ctx, config, hostConfig, netConfig, nil, containerName)
+	if err != nil {
+		if !dockerclient.IsErrNotFound(err) {
+			return resp, err
+		}
+
+		// Pull the missing image and create the container again.
+		if err = cli.pullImageWithProgress(ctx, config.Image, machine.Machine.Name, eventID); err != nil {
+			return resp, err
+		}
+		if resp, err = cli.Docker.CreateContainer(ctx, config, hostConfig, netConfig, nil, containerName); err != nil {
+			return resp, err
+		}
+	}
+	pw.Event(progress.CreatedEvent(eventID))
+
+	return resp, nil
+}
+
+func (cli *Client) pullImageWithProgress(ctx context.Context, image, machineName, parentEventID string) error {
+	pw := progress.ContextWriter(ctx)
+	eventID := fmt.Sprintf("Image %s on %s", image, machineName)
+	pw.Event(progress.Event{
+		ID:         eventID,
+		ParentID:   parentEventID,
+		Status:     progress.Working,
+		StatusText: "Pulling",
+	})
+
+	pullCh, err := cli.Docker.PullImage(ctx, image)
+	if err != nil {
+		statusErr := status.Convert(err)
+		pw.Event(progress.Event{
+			ID:         eventID,
+			ParentID:   parentEventID,
+			Text:       "Error",
+			Status:     progress.Error,
+			StatusText: statusErr.Message(),
+		})
+		return fmt.Errorf("pull image: %w", errors.New(statusErr.Message()))
+	}
+
+	// Wait for pull to complete by reading all progress messages and converting them to events.
+	for msg := range pullCh {
+		if msg.Err != nil {
+			err = msg.Err
+		} else {
+			if msg.Message.Error != nil {
+				err = errors.New(msg.Message.Error.Message)
+			}
+		}
+		if err != nil {
+			statusErr := status.Convert(err)
+			pw.Event(progress.Event{
+				ID:         eventID,
+				ParentID:   parentEventID,
+				Text:       "Error",
+				Status:     progress.Error,
+				StatusText: statusErr.Message(),
+			})
+			return fmt.Errorf("pull image: %w", errors.New(statusErr.Message()))
+		}
+
+		// TODO: add like in compose: --quiet-pull Pull without printing progress information
+		e := toPullProgressEvent(msg.Message)
+		if e != nil {
+			e.ID = fmt.Sprintf("%s on %s", e.ID, machineName)
+			e.ParentID = eventID
+			// Grand children events are not printed by the tty progress writer but they are still required
+			// to calculate the progress line of their parent.
+			pw.Event(*e)
+		}
+	}
+	pw.Event(progress.Event{
+		ID:         eventID,
+		ParentID:   parentEventID,
+		Status:     progress.Done,
+		StatusText: "Pulled",
+	})
+
+	return nil
+}
+
+// toPullProgressEvent converts a JSON progress message from the Docker API to a progress event.
+// It's based on toPullProgressEvent from Docker Compose.
+func toPullProgressEvent(jm jsonmessage.JSONMessage) *progress.Event {
+	if jm.ID == "" || jm.Progress == nil {
+		return nil
+	}
+
+	var (
+		total   int64
+		percent int
+		current int64
+	)
+	text := jm.Progress.String()
+	stat := progress.Working
+
+	switch jm.Status {
+	case "Preparing", "Waiting", "Pulling fs layer":
+		percent = 0
+	case "Downloading", "Extracting", "Verifying Checksum":
+		current = jm.Progress.Current
+		total = jm.Progress.Total
+		if jm.Progress.Total > 0 {
+			percent = int(jm.Progress.Current * 100 / jm.Progress.Total)
+		}
+	case "Download complete", "Already exists", "Pull complete":
+		stat = progress.Done
+		percent = 100
+	}
+
+	if strings.Contains(jm.Status, "Image is up to date") ||
+		strings.Contains(jm.Status, "Downloaded newer image") {
+		stat = progress.Done
+		percent = 100
+	}
+
+	return &progress.Event{
+		ID:         jm.ID,
+		Current:    current,
+		Total:      total,
+		Percent:    percent,
+		Text:       jm.Status,
+		Status:     stat,
+		StatusText: text,
+	}
+}
+
+// InspectContainer returns the information about the specified container within the service.
+func (cli *Client) InspectContainer(ctx context.Context, serviceID, containerID string) (api.MachineContainer, error) {
+	var ctr api.MachineContainer
+
+	svc, err := cli.InspectService(ctx, serviceID)
+	if err != nil {
+		return ctr, fmt.Errorf("inspect service: %w", err)
+	}
+
+	for _, c := range svc.Containers {
+		if c.Container.ID == containerID || c.Container.NameWithoutSlash() == containerID {
+			ctr = c
+		}
+	}
+	if ctr.MachineID == "" {
+		return ctr, ErrNotFound
+	}
+
+	return ctr, nil
+}
+
+// StartContainer starts the specified container within the service.
+func (cli *Client) StartContainer(ctx context.Context, serviceID, containerID string) error {
+	ctr, err := cli.InspectContainer(ctx, serviceID, containerID)
+	if err != nil {
+		return err
+	}
+
+	machine, err := cli.InspectMachine(ctx, ctr.MachineID)
+	if err != nil {
+		return fmt.Errorf("inspect machine '%s': %w", ctr.MachineID, err)
+	}
+	ctx = proxyToMachine(ctx, machine.Machine)
+
+	pw := progress.ContextWriter(ctx)
+	eventID := fmt.Sprintf("Container %s on %s", ctr.Container.NameWithoutSlash(), machine.Machine.Name)
+
+	pw.Event(progress.StartingEvent(eventID))
+	if err = cli.Docker.StartContainer(ctx, ctr.Container.ID, container.StartOptions{}); err != nil {
+		return err
+	}
+	pw.Event(progress.StartedEvent(eventID))
+
+	return nil
+}
+
+// StopContainer stops the specified container within the service.
+func (cli *Client) StopContainer(
+	ctx context.Context, serviceID, containerID string, opts container.StopOptions,
+) error {
+	ctr, err := cli.InspectContainer(ctx, serviceID, containerID)
+	if err != nil {
+		return err
+	}
+
+	machine, err := cli.InspectMachine(ctx, ctr.MachineID)
+	if err != nil {
+		return fmt.Errorf("inspect machine '%s': %w", ctr.MachineID, err)
+	}
+	ctx = proxyToMachine(ctx, machine.Machine)
+
+	pw := progress.ContextWriter(ctx)
+	eventID := fmt.Sprintf("Container %s on %s", ctr.Container.NameWithoutSlash(), machine.Machine.Name)
+
+	pw.Event(progress.StoppingEvent(eventID))
+	if err = cli.Docker.StopContainer(ctx, ctr.Container.ID, opts); err != nil {
+		return err
+	}
+	pw.Event(progress.StoppedEvent(eventID))
+
+	return nil
+}
+
+// RemoveContainer removes the specified container within the service.
+func (cli *Client) RemoveContainer(
+	ctx context.Context, serviceID, containerID string, opts container.RemoveOptions,
+) error {
+	ctr, err := cli.InspectContainer(ctx, serviceID, containerID)
+	if err != nil {
+		return err
+	}
+
+	machine, err := cli.InspectMachine(ctx, ctr.MachineID)
+	if err != nil {
+		return fmt.Errorf("inspect machine '%s': %w", ctr.MachineID, err)
+	}
+	ctx = proxyToMachine(ctx, machine.Machine)
+
+	pw := progress.ContextWriter(ctx)
+	eventID := fmt.Sprintf("Container %s on %s", ctr.Container.NameWithoutSlash(), machine.Machine.Name)
+
+	pw.Event(progress.RemovingEvent(eventID))
+	if err = cli.Docker.RemoveContainer(ctx, ctr.Container.ID, opts); err != nil {
+		return err
+	}
+	pw.Event(progress.RemovedEvent(eventID))
+
+	return nil
+}

internal/cli/client/deploy.go

@@ -0,0 +1,113 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/api/pb"
+)
+
+// Deployment manages the process of creating or updating a service to match a desired state.
+// It coordinates the validation, planning, and execution of deployment operations.
+type Deployment struct {
+	Service  *api.Service
+	Spec     api.ServiceSpec
+	Strategy Strategy
+	cli      *Client
+	plan     *Plan
+}
+
+type Plan struct {
+	ServiceID string
+	SequenceOperation
+}
+
+// MachineFilter determines which machines participate in a deployment operation by returning true for
+// machines that should be included.
+type MachineFilter func(m *pb.MachineInfo) bool
+
+var ErrNoMatchingMachines = errors.New("no machines match the filter")
+
+// NewDeployment creates a new deployment for the given service specification.
+// If strategy is nil, a default RollingStrategy will be used.
+func (cli *Client) NewDeployment(spec api.ServiceSpec, strategy Strategy) (*Deployment, error) {
+	if strategy == nil {
+		strategy = &RollingStrategy{}
+	}
+
+	return &Deployment{
+		Spec:     spec,
+		Strategy: strategy,
+		cli:      cli,
+	}, nil
+}
+
+// Plan returns a plan of operations to reconcile the service to the desired state.
+// If a plan has already been created, the same plan will be returned.
+func (d *Deployment) Plan(ctx context.Context) (Plan, error) {
+	if d.plan != nil {
+		return *d.plan, nil
+	}
+
+	// Validate the new spec before planning.
+	if err := d.Validate(ctx); err != nil {
+		return Plan{}, fmt.Errorf("invalid deployment: %w", err)
+	}
+
+	plan, err := d.Strategy.Plan(ctx, d.cli, d.Service, d.Spec)
+	if err != nil {
+		return Plan{}, fmt.Errorf("create plan using %s strategy: %w", d.Strategy.Type(), err)
+	}
+	d.plan = &plan
+
+	return plan, nil
+}
+
+// Validate checks if the deployment specification is valid.
+func (d *Deployment) Validate(ctx context.Context) error {
+	if err := d.Spec.Validate(); err != nil {
+		return fmt.Errorf("invalid service spec: %w", err)
+	}
+	if d.Spec.Name == "" {
+		return errors.New("service name is required")
+	}
+
+	if d.Service == nil {
+		svc, err := d.cli.InspectService(ctx, d.Spec.Name)
+		if err == nil {
+			d.Service = &svc
+		} else if !errors.Is(err, ErrNotFound) {
+			return fmt.Errorf("inspect service: %w", err)
+		}
+	}
+	// d.Service is nil if the service doesn't exist yet (first deployment).
+	if d.Service == nil {
+		return nil
+	}
+
+	if d.Service.Name != d.Spec.Name {
+		return errors.New("service name cannot be changed")
+	}
+	if d.Service.Mode != d.Spec.Mode {
+		return errors.New("service mode cannot be changed")
+	}
+	if d.Spec.Mode == api.ServiceModeReplicated && d.Spec.Replicas < 1 {
+		return errors.New("number of replicas must be at least 1")
+	}
+
+	return nil
+}
+
+// Run executes the deployment plan and returns the ID of the created or updated service.
+// It will create a new plan if one hasn't been created yet. The deployment will either create a new service or update
+// the existing one to match the desired specification.
+// TODO: forbid to run the same deployment more than once.
+func (d *Deployment) Run(ctx context.Context) (string, error) {
+	plan, err := d.Plan(ctx)
+	if err != nil {
+		return "", fmt.Errorf("create plan: %w", err)
+	}
+
+	return plan.ServiceID, plan.Execute(ctx, d.cli)
+}

internal/cli/client/dns.go

@@ -0,0 +1,161 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/docker/compose/v2/pkg/progress"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"io"
+	"net/http"
+	"sync"
+	"time"
+	"uncloud/internal/machine/api/pb"
+	"uncloud/internal/machine/caddyfile"
+)
+
+// GetDomain returns the cluster domain name or ErrNotFound if it hasn't been reserved yet.
+func (cli *Client) GetDomain(ctx context.Context) (string, error) {
+	domain, err := cli.ClusterClient.GetDomain(ctx, nil)
+	if err != nil {
+		if status.Convert(err).Code() == codes.NotFound {
+			return "", ErrNotFound
+		}
+		return "", err
+	}
+
+	return domain.Name, nil
+}
+
+var ErrNoReachableMachines = errors.New("no internet-reachable machines running service containers")
+
+// CreateIngressRecords verifies which machines running the specified service (typically Caddy) are reachable from
+// the internet, then creates DNS records for the cluster domain pointing to those machines. It tests each machine
+// by sending HTTP requests to their public IPs. Only machines that respond correctly with their machine ID are included
+// in the resulting DNS configuration. Returns the created DNS records or an error.
+func (cli *Client) CreateIngressRecords(ctx context.Context, serviceID string) ([]*pb.DNSRecord, error) {
+	svc, err := cli.InspectService(ctx, serviceID)
+	if err != nil {
+		return nil, fmt.Errorf("inspect service '%s': %w", serviceID, err)
+	}
+
+	machineIDs := make(map[string]struct{}, len(svc.Containers))
+	for _, mc := range svc.Containers {
+		machineIDs[mc.MachineID] = struct{}{}
+	}
+
+	var wg sync.WaitGroup
+	reachableMachines := make(chan *pb.MachineInfo)
+
+	for id := range machineIDs {
+		m, err := cli.InspectMachine(ctx, id)
+		if err != nil {
+			return nil, fmt.Errorf("inspect machine '%s': %w", id, err)
+		}
+
+		if m.Machine.PublicIp == nil {
+			continue
+		}
+
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			// Verify that the Caddy container is reachable on the machine by its public IP.
+			publicIP, _ := m.Machine.PublicIp.ToAddr()
+
+			pw := progress.ContextWriter(ctx)
+			eventID := fmt.Sprintf("Machine %s (%s)", m.Machine.Name, publicIP)
+			pw.Event(progress.NewEvent(eventID, progress.Working, "Querying"))
+
+			verifyURL := fmt.Sprintf("http://%s%s", publicIP, caddyfile.VerifyPath)
+
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, verifyURL, nil)
+			if err != nil {
+				pw.Event(progress.NewEvent(eventID, progress.Error, err.Error()))
+				return
+			}
+
+			client := &http.Client{Timeout: 5 * time.Second}
+			resp, err := client.Do(req)
+			if err != nil {
+				e := unreachable(eventID)
+				e.Text = fmt.Sprintf("Failed to send HTTP request: %v", err)
+				pw.Event(e)
+				return
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != http.StatusOK {
+				e := unreachable(eventID)
+				e.Text = fmt.Sprintf("Unexpected HTTP response status code: %d", resp.StatusCode)
+				pw.Event(e)
+				return
+			}
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				e := unreachable(eventID)
+				e.Text = fmt.Sprintf("Failed to read HTTP response body: %v", err)
+				pw.Event(e)
+				return
+			}
+
+			// Check the response body is the machine ID to ensure the correct Caddy container is responding.
+			if string(body) == m.Machine.Id {
+				pw.Event(progress.NewEvent(eventID, progress.Done, "Reachable"))
+				reachableMachines <- m.Machine
+			} else {
+				bodyStr := string(body)
+				if len(bodyStr) > 50 {
+					bodyStr = bodyStr[:50] + "..."
+				}
+
+				e := unreachable(eventID)
+				e.Text = fmt.Sprintf("Unexpected HTTP response body: %s", bodyStr)
+				pw.Event(e)
+			}
+		}()
+	}
+
+	go func() {
+		wg.Wait()
+		close(reachableMachines)
+	}()
+
+	var ingressIPs []string
+	for m := range reachableMachines {
+		ip, _ := m.PublicIp.ToAddr()
+		ingressIPs = append(ingressIPs, ip.String())
+	}
+	if len(ingressIPs) == 0 {
+		return nil, ErrNoReachableMachines
+	}
+
+	req := &pb.CreateDomainRecordsRequest{
+		Records: []*pb.DNSRecord{
+			{
+				Name:   "*",
+				Type:   pb.DNSRecord_A,
+				Values: ingressIPs,
+			},
+			// TODO: Add AAAA record with routable IPv6 addresses of machines running Caddy containers.
+		},
+	}
+	resp, err := cli.CreateDomainRecords(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("create cluster domain records in Uncloud DNS: %w", err)
+	}
+
+	return resp.Records, nil
+}
+
+// unreachable creates a new Unreachable error event.
+func unreachable(id string) progress.Event {
+	return progress.NewEvent(
+		id,
+		progress.Error,
+		"Unreachable (probably behind NAT or firewall)",
+	)
+}

internal/cli/client/operation.go

@@ -0,0 +1,166 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/docker/api/types/container"
+	"strings"
+	"uncloud/internal/api"
+)
+
+// Operation represents a single atomic operation in a deployment process.
+// Operations can be composed to form complex deployment strategies.
+type Operation interface {
+	Execute(ctx context.Context, cli *Client) error
+	// Format returns a human-readable representation of the operation.
+	Format(resolver NameResolver) string
+	String() string
+}
+
+// NameResolver resolves machine and container IDs to their names.
+type NameResolver interface {
+	MachineName(machineID string) string
+	ContainerName(containerID string) string
+}
+
+// RunContainerOperation creates and starts a new container on a specific machine.
+type RunContainerOperation struct {
+	ServiceID string
+	Spec      api.ServiceSpec
+	MachineID string
+}
+
+func (o *RunContainerOperation) Execute(ctx context.Context, cli *Client) error {
+	resp, err := cli.CreateContainer(ctx, o.ServiceID, o.Spec, o.MachineID)
+	if err != nil {
+		return fmt.Errorf("create container: %w", err)
+	}
+	if err = cli.StartContainer(ctx, o.ServiceID, resp.ID); err != nil {
+		return fmt.Errorf("start container: %w", err)
+	}
+
+	// TODO: wait for the container to become healthy
+
+	return nil
+}
+
+func (o *RunContainerOperation) Format(resolver NameResolver) string {
+	machineName := resolver.MachineName(o.MachineID)
+	return fmt.Sprintf("%s: Run container [image=%s]", machineName, o.Spec.Container.Image)
+}
+
+func (o *RunContainerOperation) String() string {
+	return fmt.Sprintf("RunContainerOperation[service_id=%s, image=%s, machine_id=%s]",
+		o.ServiceID, o.Spec.Container.Image, o.MachineID)
+}
+
+// StopContainerOperation stops a container on a specific machine.
+type StopContainerOperation struct {
+	ServiceID   string
+	ContainerID string
+	MachineID   string
+}
+
+func (o *StopContainerOperation) Execute(ctx context.Context, cli *Client) error {
+	if err := cli.StopContainer(ctx, o.ServiceID, o.ContainerID, container.StopOptions{}); err != nil {
+		return fmt.Errorf("stop container: %w", err)
+	}
+	return nil
+}
+
+func (o *StopContainerOperation) Format(resolver NameResolver) string {
+	machineName := resolver.MachineName(o.MachineID)
+	return fmt.Sprintf("%s: Stop container [name=%s]", machineName, resolver.ContainerName(o.ContainerID))
+}
+
+func (o *StopContainerOperation) String() string {
+	return fmt.Sprintf("StopContainerOperation[service_id=%s, container_id=%s, machine_id=%s]",
+		o.ServiceID, o.ContainerID, o.MachineID)
+}
+
+// RemoveContainerOperation stops and removes a container from a specific machine.
+type RemoveContainerOperation struct {
+	ServiceID   string
+	ContainerID string
+	MachineID   string
+}
+
+func (o *RemoveContainerOperation) Execute(ctx context.Context, cli *Client) error {
+	if err := cli.StopContainer(ctx, o.ServiceID, o.ContainerID, container.StopOptions{}); err != nil {
+		return fmt.Errorf("stop container: %w", err)
+	}
+	if err := cli.RemoveContainer(ctx, o.ServiceID, o.ContainerID, container.RemoveOptions{}); err != nil {
+		return fmt.Errorf("remove container: %w", err)
+	}
+
+	return nil
+}
+
+func (o *RemoveContainerOperation) Format(resolver NameResolver) string {
+	machineName := resolver.MachineName(o.MachineID)
+	return fmt.Sprintf("%s: Remove container [name=%s]", machineName, resolver.ContainerName(o.ContainerID))
+}
+
+func (o *RemoveContainerOperation) String() string {
+	return fmt.Sprintf("RemoveContainerOperation[service_id=%s, container_id=%s, machine_id=%s]",
+		o.ServiceID, o.ContainerID, o.MachineID)
+}
+
+// SequenceOperation is a composite operation that executes a sequence of operations in order.
+type SequenceOperation struct {
+	Operations []Operation
+}
+
+func (o *SequenceOperation) Execute(ctx context.Context, cli *Client) error {
+	for _, op := range o.Operations {
+		if err := op.Execute(ctx, cli); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (o *SequenceOperation) Format(resolver NameResolver) string {
+	ops := make([]string, len(o.Operations))
+	for i, op := range o.Operations {
+		ops[i] = "- " + op.Format(resolver)
+	}
+
+	return strings.Join(ops, "\n")
+}
+
+func (o *SequenceOperation) String() string {
+	ops := make([]string, len(o.Operations))
+	for i, op := range o.Operations {
+		ops[i] = op.String()
+	}
+
+	return fmt.Sprintf("SequenceOperation[%s]", strings.Join(ops, ", "))
+}
+
+// MapNameResolver resolves machine and container IDs to their names using a static map.
+type MapNameResolver struct {
+	machines   map[string]string
+	containers map[string]string
+}
+
+func NewNameResolver(machines, containers map[string]string) *MapNameResolver {
+	return &MapNameResolver{
+		machines:   machines,
+		containers: containers,
+	}
+}
+
+func (r *MapNameResolver) MachineName(machineID string) string {
+	if name, ok := r.machines[machineID]; ok {
+		return name
+	}
+	return machineID
+}
+
+func (r *MapNameResolver) ContainerName(containerID string) string {
+	if name, ok := r.containers[containerID]; ok {
+		return name
+	}
+	return containerID
+}

internal/cli/client/resolver.go

@@ -0,0 +1,116 @@
+package client
+
+import (
+	"fmt"
+	"github.com/distribution/reference"
+	"strings"
+	"uncloud/internal/api"
+	"uncloud/internal/secret"
+)
+
+// ServiceSpecResolver transforms user-provided service specs into deployment-ready form.
+type ServiceSpecResolver struct {
+	ClusterDomain string
+}
+
+func NewServiceSpecResolver(clusterDomain string) *ServiceSpecResolver {
+	return &ServiceSpecResolver{ClusterDomain: clusterDomain}
+}
+
+// Resolve transforms a service spec into its fully resolved form ready for deployment.
+func (r *ServiceSpecResolver) Resolve(spec *api.ServiceSpec) error {
+	if err := spec.Validate(); err != nil {
+		return fmt.Errorf("invalid service spec: %w", err)
+	}
+
+	steps := []func(*api.ServiceSpec) error{
+		r.applyDefaults,
+		r.resolveServiceName,
+		r.expandIngressPorts,
+	}
+
+	for _, step := range steps {
+		if err := step(spec); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (r *ServiceSpecResolver) applyDefaults(spec *api.ServiceSpec) error {
+	if spec.Mode == "" {
+		spec.Mode = api.ServiceModeReplicated
+	}
+	// Ensure the replicated service has at least one replica.
+	if spec.Mode == api.ServiceModeReplicated && spec.Replicas == 0 {
+		spec.Replicas = 1
+	}
+
+	return nil
+}
+
+func (r *ServiceSpecResolver) resolveServiceName(spec *api.ServiceSpec) error {
+	if spec.Name != "" {
+		return nil
+	}
+
+	// Generate a random service name from the image when not provided.
+	img, err := reference.ParseDockerRef(spec.Container.Image)
+	if err != nil {
+		return fmt.Errorf("invalid image: %w", err)
+	}
+	// Get the image name without the repository and tag/digest parts.
+	imageName := reference.FamiliarName(img)
+	// Get the last part of the image name (path), e.g. "nginx" from "bitnami/nginx".
+	if i := strings.LastIndex(imageName, "/"); i != -1 {
+		imageName = imageName[i+1:]
+	}
+	// Append a random suffix to the image name to generate an optimistically unique service name.
+	suffix, err := secret.RandomAlphaNumeric(4)
+	if err != nil {
+		return fmt.Errorf("generate random suffix: %w", err)
+	}
+	spec.Name = fmt.Sprintf("%s-%s", imageName, suffix)
+
+	return nil
+}
+
+// expandIngressPorts processes HTTP(S) ingress ports in a service spec by:
+// 1. Setting a default hostname (service-name.cluster-domain) for ports without a hostname.
+// 2. Duplicating a port with a cluster domain hostname for ports with external domains.
+// This ensures every ingress port is accessible via the cluster domain, while preserving any custom domains specified
+// by the user.
+func (r *ServiceSpecResolver) expandIngressPorts(spec *api.ServiceSpec) error {
+	for i, port := range spec.Ports {
+		if port.Protocol != api.ProtocolHTTP && port.Protocol != api.ProtocolHTTPS {
+			continue
+		}
+
+		if port.Hostname == "" {
+			if r.ClusterDomain == "" {
+				return fmt.Errorf("cluster domain must be reserved to generate hostname for ingress port: %d/%s",
+					port.ContainerPort, port.Protocol)
+			}
+			// Assign the default hostname (service-name.cluster-domain).
+			spec.Ports[i].Hostname = fmt.Sprintf("%s.%s", spec.Name, r.ClusterDomain)
+		} else {
+			if r.ClusterDomain == "" {
+				// When no cluster domain is reserved, use only the provided hostname.
+				continue
+			}
+
+			if strings.HasSuffix(port.Hostname, "."+r.ClusterDomain) {
+				// If the hostname is already a cluster subdomain, use as is.
+				continue
+			}
+			// For external domains, duplicate the port with a service-name.cluster-domain hostname so the service
+			// can be accessed via both hostnames.
+			newPort := port
+			newPort.Hostname = fmt.Sprintf("%s.%s", spec.Name, r.ClusterDomain)
+			spec.Ports = append(spec.Ports, newPort)
+		}
+	}
+
+	return nil
+}

internal/cli/client/service.go

@@ -0,0 +1,343 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/docker/compose/v2/pkg/progress"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+	"slices"
+	"sync"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/api/pb"
+)
+
+func (cli *Client) PrepareDeploymentSpec(ctx context.Context, spec api.ServiceSpec) (api.ServiceSpec, error) {
+	domain, err := cli.GetDomain(ctx)
+	if err != nil && !errors.Is(err, ErrNotFound) {
+		return spec, fmt.Errorf("get domain: %w", err)
+	}
+
+	// If the domain is not found (not reserved), an empty domain is used for the resolver.
+	resolver := NewServiceSpecResolver(domain)
+
+	if err = resolver.Resolve(&spec); err != nil {
+		return spec, err
+	}
+
+	return spec, nil
+}
+
+type RunServiceResponse struct {
+	ID   string
+	Name string
+}
+
+func (cli *Client) RunService(
+	ctx context.Context, spec api.ServiceSpec, filter MachineFilter,
+) (RunServiceResponse, error) {
+	var resp RunServiceResponse
+
+	if err := spec.Validate(); err != nil {
+		return resp, fmt.Errorf("invalid service spec: %w", err)
+	}
+
+	if spec.Name != "" {
+		// Optimistically check if a service with the specified name already exists.
+		_, err := cli.InspectService(ctx, spec.Name)
+		if err == nil {
+			return resp, fmt.Errorf("service with name '%s' already exists", spec.Name)
+		}
+		if !errors.Is(err, ErrNotFound) {
+			return resp, fmt.Errorf("inspect service: %w", err)
+		}
+	}
+
+	var err error
+	if spec, err = cli.PrepareDeploymentSpec(ctx, spec); err != nil {
+		return resp, fmt.Errorf("prepare service spec ready for deployment: %w", err)
+	}
+
+	err = progress.RunWithTitle(ctx, func(ctx context.Context) error {
+		deploy, err := cli.NewDeployment(spec, &RollingStrategy{MachineFilter: filter})
+		if err != nil {
+			return fmt.Errorf("create deployment: %w", err)
+		}
+
+		serviceID, err := deploy.Run(ctx)
+		if err != nil {
+			return err
+		}
+
+		resp.ID = serviceID
+		// TODO: get the service name from the plan when it's available.
+		resp.Name = spec.Name
+
+		return nil
+	}, cli.progressOut(), fmt.Sprintf("Running service %s (%s mode)", spec.Name, spec.Mode))
+
+	return resp, err
+}
+
+// InspectService returns detailed information about a service and its containers.
+// The id parameter can be either a service ID or name.
+func (cli *Client) InspectService(ctx context.Context, id string) (api.Service, error) {
+	var svc api.Service
+
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return svc, fmt.Errorf("list machines: %w", err)
+	}
+
+	// Broadcast the container list request to all available machines.
+	machineIDByManagementIP := make(map[string]string)
+	md := metadata.New(nil)
+	for _, m := range machines {
+		if m.State == pb.MachineMember_UP || m.State == pb.MachineMember_SUSPECT {
+			machineIP, _ := m.Machine.Network.ManagementIp.ToAddr()
+			md.Append("machines", machineIP.String())
+
+			machineIDByManagementIP[machineIP.String()] = m.Machine.Id
+		}
+		// TODO: warning about machines that are DOWN.
+	}
+	listCtx := metadata.NewOutgoingContext(ctx, md)
+
+	// List only uncloud-managed containers that belong to some service.
+	opts := container.ListOptions{
+		All: true,
+		Filters: filters.NewArgs(
+			filters.Arg("label", api.LabelServiceID),
+			filters.Arg("label", api.LabelManaged),
+		),
+	}
+	machineContainers, err := cli.Docker.ListContainers(listCtx, opts)
+	if err != nil {
+		return svc, fmt.Errorf("list containers: %w", err)
+	}
+
+	// Collect all containers on all machines that belong to the specified service.
+	foundByID := false
+	var containers []api.MachineContainer
+	for _, mc := range machineContainers {
+		// Metadata can be nil if the request was broadcasted to only one machine.
+		if mc.Metadata == nil && len(machineContainers) > 1 {
+			return svc, errors.New("something went wrong with gRPC proxy: metadata is missing for a machine response")
+		}
+		if mc.Metadata != nil && mc.Metadata.Error != "" {
+			// TODO: return failed machines in the response.
+			fmt.Printf("WARNING: failed to list containers on machine '%s': %s\n",
+				mc.Metadata.Machine, mc.Metadata.Error)
+			continue
+		}
+
+		machineID := ""
+		if mc.Metadata == nil {
+			// ListContainers was proxied to only one machine.
+			for _, v := range machineIDByManagementIP {
+				machineID = v
+				break
+			}
+		} else {
+			var ok bool
+			machineID, ok = machineIDByManagementIP[mc.Metadata.Machine]
+			if !ok {
+				return svc, fmt.Errorf("machine name not found for management IP: %s", mc.Metadata.Machine)
+			}
+		}
+
+		for _, c := range mc.Containers {
+			ctr := api.Container{ContainerJSON: c}
+			if ctr.ServiceID() == id || ctr.ServiceName() == id {
+				containers = append(containers, api.MachineContainer{
+					MachineID: machineID,
+					Container: ctr,
+				})
+
+				if ctr.ServiceID() == id {
+					foundByID = true
+				}
+			}
+		}
+	}
+
+	if len(containers) == 0 {
+		return svc, ErrNotFound
+	}
+
+	// Containers from different services may share the same service name (distributed and eventually consistent store
+	// may not prevent this), or a service name might match another service's ID. In these cases, matching by ID takes
+	// priority over matching by name.
+	if foundByID {
+		containers = slices.DeleteFunc(containers, func(mc api.MachineContainer) bool {
+			return mc.Container.ServiceID() != id
+		})
+	} else {
+		// Matched only by name but there could be multiple services with the same name.
+		serviceID := containers[0].Container.ServiceID()
+		for _, mc := range containers[1:] {
+			if mc.Container.ServiceID() != serviceID {
+				return svc, fmt.Errorf("multiple services found with name '%s', use the service ID instead", id)
+			}
+		}
+	}
+
+	svc = api.Service{
+		ID:         containers[0].Container.ServiceID(),
+		Name:       containers[0].Container.ServiceName(),
+		Mode:       containers[0].Container.ServiceMode(),
+		Containers: containers,
+	}
+	if svc.Mode == "" {
+		svc.Mode = api.ServiceModeReplicated
+	}
+
+	return svc, nil
+}
+
+// InspectServiceFromStore returns detailed information about a service and its containers from the distributed store.
+// Due to eventual consistency of the store, the returned information may not reflect the most recent changes.
+// The id parameter can be either a service ID or name.
+func (cli *Client) InspectServiceFromStore(ctx context.Context, id string) (api.Service, error) {
+	var svc api.Service
+
+	resp, err := cli.MachineClient.InspectService(ctx, &pb.InspectServiceRequest{Id: id})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return svc, ErrNotFound
+			}
+		}
+		return svc, err
+	}
+
+	svc, err = api.ServiceFromProto(resp.Service)
+	if err != nil {
+		return svc, fmt.Errorf("from proto: %w", err)
+	}
+	return svc, nil
+}
+
+// RemoveService removes all containers on all machines that belong to the specified service.
+// The id parameter can be either a service ID or name.
+func (cli *Client) RemoveService(ctx context.Context, id string) error {
+	svc, err := cli.InspectService(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return fmt.Errorf("list machines: %w", err)
+	}
+	machineManagementIPByID := make(map[string]string)
+	for _, m := range machines {
+		machineIP, _ := m.Machine.Network.ManagementIp.ToAddr()
+		machineManagementIPByID[m.Machine.Id] = machineIP.String()
+	}
+
+	wg := sync.WaitGroup{}
+	errCh := make(chan error)
+
+	// Remove all containers on all machines that belong to the service.
+	for _, mc := range svc.Containers {
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			err := cli.StopContainer(ctx, svc.ID, mc.Container.ID, container.StopOptions{})
+			if err != nil {
+				errCh <- fmt.Errorf("stop container '%s': %w", mc.Container.ID, err)
+				return
+			}
+
+			err = cli.RemoveContainer(ctx, svc.ID, mc.Container.ID, container.RemoveOptions{})
+			if err != nil && !errors.Is(err, ErrNotFound) {
+				errCh <- fmt.Errorf("remove container '%s': %w", mc.Container.ID, err)
+			}
+		}()
+	}
+
+	go func() {
+		wg.Wait()
+		close(errCh)
+	}()
+
+	err = nil
+	for e := range errCh {
+		err = errors.Join(err, e)
+	}
+	return err
+}
+
+// ListServices returns a list of all services and their containers.
+func (cli *Client) ListServices(ctx context.Context) ([]api.Service, error) {
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("list machines: %w", err)
+	}
+
+	// Broadcast the container list request to all available machines.
+	md := metadata.New(nil)
+	for _, m := range machines {
+		if m.State == pb.MachineMember_UP || m.State == pb.MachineMember_SUSPECT {
+			machineIP, _ := m.Machine.Network.ManagementIp.ToAddr()
+			md.Append("machines", machineIP.String())
+		}
+		// TODO: warning about machines that are DOWN.
+	}
+	listCtx := metadata.NewOutgoingContext(ctx, md)
+
+	// List only uncloud-managed containers that belong to some service.
+	opts := container.ListOptions{
+		All: true,
+		Filters: filters.NewArgs(
+			filters.Arg("label", api.LabelServiceID),
+			filters.Arg("label", api.LabelManaged),
+		),
+	}
+	machineContainers, err := cli.Docker.ListContainers(listCtx, opts)
+	if err != nil {
+		return nil, fmt.Errorf("list containers: %w", err)
+	}
+
+	// TODO: optimise by extracting services from the list of all containers instead of inspecting each service.
+	//  Most of the code can be reused in both InspectService and ListServices.
+	servicesByID := make(map[string]api.Service)
+	for _, mc := range machineContainers {
+		if mc.Metadata != nil && mc.Metadata.Error != "" {
+			// TODO: return failed machines in the response.
+			fmt.Printf("WARNING: failed to list containers on machine '%s': %s\n",
+				mc.Metadata.Machine, mc.Metadata.Error)
+			continue
+		}
+
+		for _, c := range mc.Containers {
+			ctr := api.Container{ContainerJSON: c}
+			if _, ok := servicesByID[ctr.ServiceID()]; ok {
+				continue
+			}
+
+			svc, err := cli.InspectService(ctx, ctr.ServiceID())
+			if err != nil {
+				if errors.Is(err, ErrNotFound) {
+					continue
+				}
+				return nil, fmt.Errorf("inspect service: %w", err)
+			}
+
+			servicesByID[ctr.ServiceID()] = svc
+		}
+	}
+
+	services := make([]api.Service, 0, len(servicesByID))
+	for _, svc := range servicesByID {
+		services = append(services, svc)
+	}
+	return services, nil
+}

internal/cli/client/strategy.go

@@ -0,0 +1,364 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"math/rand/v2"
+	"slices"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/api/pb"
+	"uncloud/internal/secret"
+)
+
+// Strategy defines how a service should be deployed or updated. Different implementations can provide various
+// deployment patterns such as rolling updates, blue/green deployments, etc.
+type Strategy interface {
+	// Type returns the type of the deployment strategy, e.g. "rolling", "blue-green".
+	Type() string
+	// Plan returns the operation to reconcile the service to the desired state.
+	// If the service does not exist (new deployment), svc will be nil.
+	Plan(ctx context.Context, cli *Client, svc *api.Service, spec api.ServiceSpec) (Plan, error)
+}
+
+// RollingStrategy implements a rolling update deployment pattern where containers are updated one at a time
+// to minimize service disruption.
+type RollingStrategy struct {
+	// MachineFilter optionally restricts which machines can be used for deployment.
+	MachineFilter MachineFilter
+}
+
+func (s *RollingStrategy) Type() string {
+	return "rolling"
+}
+
+func (s *RollingStrategy) Plan(
+	ctx context.Context, cli *Client, svc *api.Service, spec api.ServiceSpec,
+) (Plan, error) {
+	switch spec.Mode {
+	case api.ServiceModeReplicated:
+		return s.planReplicated(ctx, cli, svc, spec)
+	case api.ServiceModeGlobal:
+		return s.planGlobal(ctx, cli, svc, spec)
+	default:
+		return Plan{}, fmt.Errorf("unsupported service mode: %s", spec.Mode)
+	}
+}
+
+// planReplicated creates a plan for a replicated service deployment.
+// For replicated services, we want to maintain a specific number of containers (replicas) across the available machines
+// in the cluster.
+func (s *RollingStrategy) planReplicated(
+	ctx context.Context, cli *Client, svc *api.Service, spec api.ServiceSpec,
+) (Plan, error) {
+	var plan Plan
+
+	// Generate a new service ID for the first service deployment if it doesn't exist yet.
+	if svc != nil {
+		plan.ServiceID = svc.ID
+	} else {
+		var err error
+		plan.ServiceID, err = secret.NewID()
+		if err != nil {
+			return plan, fmt.Errorf("generate service ID: %w", err)
+		}
+	}
+
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return plan, fmt.Errorf("list machines: %w", err)
+	}
+	// Filter machines that are not DOWN and match the machine filter if provided.
+	var availableMachines []*pb.MachineInfo
+	var unmatchedMachines []*pb.MachineInfo
+	var downMachines []*pb.MachineInfo
+	for _, m := range machines {
+		if m.State == pb.MachineMember_DOWN {
+			downMachines = append(downMachines, m.Machine)
+		} else {
+			if s.MachineFilter == nil || s.MachineFilter(m.Machine) {
+				availableMachines = append(availableMachines, m.Machine)
+			} else {
+				unmatchedMachines = append(unmatchedMachines, m.Machine)
+			}
+		}
+	}
+
+	if len(availableMachines) == 0 {
+		if s.MachineFilter != nil {
+			return plan, ErrNoMatchingMachines
+		}
+		return plan, fmt.Errorf("no available machines to deploy service")
+	}
+	// Randomise the order of machines to avoid always deploying to the same machines first.
+	rand.Shuffle(len(availableMachines), func(i, j int) {
+		availableMachines[i], availableMachines[j] = availableMachines[j], availableMachines[i]
+	})
+
+	// Organise existing containers by machine.
+	containersOnMachine := make(map[string][]api.Container)
+	upToDateContainersOnMachine := make(map[string]int)
+	if svc != nil {
+		runningSpecs := make(map[string]api.ServiceSpec)
+		for _, c := range svc.Containers {
+			if !c.Container.State.Running || c.Container.State.Paused {
+				// Skip containers that are not running.
+				continue
+			}
+			cs, err := c.Container.ServiceSpec()
+			if err == nil {
+				runningSpecs[c.Container.ID] = cs
+				if cs.Equals(spec) {
+					upToDateContainersOnMachine[c.MachineID] += 1
+				}
+			}
+		}
+
+		// Sort containers such that containers with the desired spec are first.
+		slices.SortFunc(svc.Containers, func(c1, c2 api.MachineContainer) int {
+			if spec1, ok := runningSpecs[c1.Container.ID]; ok && spec1.Equals(spec) {
+				return -1
+			}
+			if spec2, ok := runningSpecs[c2.Container.ID]; ok && spec2.Equals(spec) {
+				return 1
+			}
+			return 0
+		})
+
+		for _, c := range svc.Containers {
+			containersOnMachine[c.MachineID] = append(containersOnMachine[c.MachineID], c.Container)
+		}
+
+		// Sort machines such that machines with the most up-to-date containers are first, followed by machines with
+		// existing containers, and finally machines without containers.
+		slices.SortFunc(availableMachines, func(m1, m2 *pb.MachineInfo) int {
+			if upToDateContainersOnMachine[m1.Id] > 0 && upToDateContainersOnMachine[m2.Id] > 0 {
+				return upToDateContainersOnMachine[m2.Id] - upToDateContainersOnMachine[m1.Id]
+			}
+			if upToDateContainersOnMachine[m1.Id] > 0 {
+				return -1
+			}
+			if upToDateContainersOnMachine[m2.Id] > 0 {
+				return 1
+			}
+			return len(containersOnMachine[m2.Id]) - len(containersOnMachine[m1.Id])
+		})
+	}
+
+	// Spread the containers across the available machines evenly using a simple round-robin approach, starting with
+	// machines that already have containers and prioritising machines with containers that match the desired spec.
+	for i := 0; i < int(spec.Replicas); i++ {
+		m := availableMachines[i%len(availableMachines)]
+		containers := containersOnMachine[m.Id]
+
+		if len(containers) == 0 {
+			// No more existing containers on this machine, create a new one.
+			plan.Operations = append(plan.Operations, &RunContainerOperation{
+				ServiceID: plan.ServiceID,
+				Spec:      spec,
+				MachineID: m.Id,
+			})
+			continue
+		}
+
+		ctr := containers[0]
+		containersOnMachine[m.Id] = containers[1:]
+
+		if ctr.State.Running {
+			ctrSpec, specErr := ctr.ServiceSpec()
+			if specErr == nil && ctrSpec.Equals(spec) {
+				continue
+			}
+
+			conflictingPorts, portsErr := ctr.ConflictingServicePorts(spec.Ports)
+			if specErr != nil || portsErr != nil || len(conflictingPorts) > 0 {
+				// Stop the malformed container or the container with conflicting ports.
+				plan.Operations = append(plan.Operations, &StopContainerOperation{
+					ServiceID:   plan.ServiceID,
+					ContainerID: ctr.ID,
+					MachineID:   m.Id,
+				})
+			}
+		}
+
+		// Run a new container.
+		plan.Operations = append(plan.Operations, &RunContainerOperation{
+			ServiceID: plan.ServiceID,
+			Spec:      spec,
+			MachineID: m.Id,
+		})
+
+		// Remove the old container.
+		plan.Operations = append(plan.Operations, &RemoveContainerOperation{
+			ServiceID:   plan.ServiceID,
+			ContainerID: ctr.ID,
+			MachineID:   m.Id,
+		})
+	}
+
+	// Remove any remaining containers that are not needed.
+	for mid, containers := range containersOnMachine {
+		for _, c := range containers {
+			plan.Operations = append(plan.Operations, &RemoveContainerOperation{
+				ServiceID:   plan.ServiceID,
+				ContainerID: c.ID,
+				MachineID:   mid,
+			})
+		}
+	}
+
+	return plan, nil
+}
+
+// planGlobal creates a plan for a global service deployment, ensuring one container runs on each available machine.
+// For machines with an existing container, it attempts to start a new container before removing the old one if
+// possible. If the new container would have port conflicts with the existing one, the old container is removed first.
+// It handles multiple containers per machine (though this should not occur in normal operation) and skips machines
+// that are down.
+func (s *RollingStrategy) planGlobal(
+	ctx context.Context, cli *Client, svc *api.Service, spec api.ServiceSpec,
+) (Plan, error) {
+	var plan Plan
+	// Map machineID to service containers on that machine. For the global mode, there should be at most one
+	// container per machine but we use a slice to handle multiple containers that may exist due to a bug
+	// or interruption in the previous deployment.
+	containersOnMachine := make(map[string][]api.MachineContainer)
+	if svc != nil {
+		plan.ServiceID = svc.ID
+		for _, c := range svc.Containers {
+			containersOnMachine[c.MachineID] = append(containersOnMachine[c.MachineID], c)
+		}
+	} else {
+		// Generate a new service ID for the first service deployment.
+		var err error
+		plan.ServiceID, err = secret.NewID()
+		if err != nil {
+			return plan, fmt.Errorf("generate service ID: %w", err)
+		}
+	}
+
+	machines, err := cli.ListMachines(ctx)
+	if err != nil {
+		return plan, fmt.Errorf("list machines: %w", err)
+	}
+	// Filter machines if a machine filter is provided.
+	// TODO: not sure this is the right behaviour to ignore other machines that might run service containers.
+	//  Maybe there should be another filter to specify which machines to deploy to but keep the rest running.
+	//  Could be useful to test a new version on a subset of machines before rolling out to all.
+	if s.MachineFilter != nil {
+		machines = slices.DeleteFunc(machines, func(m *pb.MachineMember) bool {
+			return !s.MachineFilter(m.Machine)
+		})
+		if len(machines) == 0 {
+			return plan, ErrNoMatchingMachines
+		}
+	}
+
+	// TODO: figure out how to return a warning if there are machines down. Embed the machinesDown in the plan?
+	//  WARNING: failed to run a service container on machine '%s' which is Down.
+	var machinesDown []*pb.MachineInfo
+	for _, m := range machines {
+		// Skip machines that are down but collect them to report a warning later.
+		if m.State == pb.MachineMember_DOWN {
+			machinesDown = append(machinesDown, m.Machine)
+			continue
+		}
+
+		containers := containersOnMachine[m.Machine.Id]
+		ops, err := reconcileGlobalContainer(containers, spec, plan.ServiceID, m.Machine.Id)
+		if err != nil {
+			return plan, err
+		}
+		plan.Operations = append(plan.Operations, ops...)
+	}
+
+	return plan, nil
+}
+
+// reconcileGlobalContainer returns a sequence of operations to reconcile containers on a machine for a global service.
+// It ensures exactly one container with the desired spec is running on the machine by creating a new container and
+// removing old ones. If there is a host port conflict, it stops the old container before starting a new one.
+func reconcileGlobalContainer(
+	containers []api.MachineContainer, spec api.ServiceSpec, serviceID, machineID string,
+) ([]Operation, error) {
+	var ops []Operation
+
+	if len(containers) == 0 {
+		// No containers on this machine, create a new one.
+		ops = append(ops, &RunContainerOperation{
+			ServiceID: serviceID,
+			Spec:      spec,
+			MachineID: machineID,
+		})
+		return ops, nil
+	}
+
+	// Check if there is a container with the same spec already running. If so, remove the rest.
+	upToDate := false
+	for i, c := range containers {
+		if !c.Container.State.Running || c.Container.State.Paused {
+			// Skip containers that are not running.
+			continue
+		}
+
+		svcSpec, err := c.Container.ServiceSpec()
+		if err != nil {
+			return nil, fmt.Errorf("get service spec: %w", err)
+		}
+		if svcSpec.Equals(spec) {
+			// The container is already running with the same spec.
+			upToDate = true
+			for j, old := range containers {
+				if i == j {
+					continue
+				}
+				ops = append(ops, &RemoveContainerOperation{
+					ServiceID:   serviceID,
+					ContainerID: old.Container.ID,
+					MachineID:   old.MachineID,
+				})
+			}
+			break
+		}
+	}
+	if upToDate {
+		return ops, nil
+	}
+
+	// The machine has containers but none of them match the new spec.
+	// Stop the old running containers that have conflicting ports with the new spec before running a new one.
+	for _, c := range containers {
+		if c.Container.State.Running {
+			conflictingPorts, err := c.Container.ConflictingServicePorts(spec.Ports)
+			if err != nil {
+				return nil, fmt.Errorf("check conflicting ports: %w", err)
+			}
+
+			if len(conflictingPorts) > 0 {
+				// Stop the running container with conflicting ports.
+				ops = append(ops, &StopContainerOperation{
+					ServiceID:   serviceID,
+					ContainerID: c.Container.ID,
+					MachineID:   c.MachineID,
+				})
+			}
+		}
+	}
+
+	// Run a new container.
+	ops = append(ops, &RunContainerOperation{
+		ServiceID: serviceID,
+		Spec:      spec,
+		MachineID: machineID,
+	})
+
+	// Remove the old containers.
+	for _, c := range containers {
+		ops = append(ops, &RemoveContainerOperation{
+			ServiceID:   serviceID,
+			ContainerID: c.Container.ID,
+			MachineID:   c.MachineID,
+		})
+	}
+
+	return ops, nil
+}

internal/cli/config/cluster.go

@@ -1,10 +1,6 @@
 package config
 
-import "uncloud/internal/secret"
-
 type Cluster struct {
 	Name        string              `toml:"-"`
 	Connections []MachineConnection `toml:"connections"`
-	// UserPrivateKey is the user's WireGuard private key used to connect to cluster machines.
-	UserPrivateKey secret.Secret `toml:"user_private_key"`
 }

internal/cli/config/connection.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"net"
+	"net/netip"
 	"strconv"
 	"strings"
 	"uncloud/internal/secret"
@@ -13,9 +14,11 @@ const (
 )
 
 type MachineConnection struct {
-	SSH       SSHDestination `toml:"ssh,omitempty"`
-	Host      string         `toml:"host,omitempty"`
-	PublicKey secret.Secret  `toml:"public_key,omitempty"`
+	SSH        SSHDestination `toml:"ssh,omitempty"`
+	TCP        netip.AddrPort `toml:"tcp,omitempty"`
+	Host       string         `toml:"host,omitempty"`
+	PublicKey  secret.Secret  `toml:"public_key,omitempty"`
+	SSHKeyFile string         `toml:"ssh_key_file,omitempty"`
 }
 
 // SSHDestination represents an SSH destination string in the canonical form of "user@host:port".

internal/cli/machine.go

@@ -17,24 +17,36 @@ type RemoteMachine struct {
 	KeyPath string
 }
 
+func installCmd(user string) string {
+	sudoPrefix := "sudo"
+	// Add the SSH user (non-root) to the uncloud group to allow access to the Uncloud daemon unix socket.
+	env := "UNCLOUD_GROUP_ADD_USER=" + user
+
+	curlBashCmd := fmt.Sprintf(
+		"curl -fsSL %s | %s %s bash", sshexec.Quote(installScriptURL), sudoPrefix, sshexec.Quote(env),
+	)
+
+	if user == "root" {
+		curlBashCmd = fmt.Sprintf(
+			"curl -fsSL %s | bash", sshexec.Quote(installScriptURL),
+		)
+	}
+
+	return curlBashCmd
+}
+
 // provisionMachine provisions the remote machine by downloading the Uncloud install script from GitHub and running it.
 func provisionMachine(ctx context.Context, exec sshexec.Executor) error {
 	user, err := exec.Run(ctx, "whoami")
 	if err != nil {
 		return fmt.Errorf("run whoami: %w", err)
 	}
-	sudoPrefix, env := "", ""
-	if user != "root" {
-		sudoPrefix = "sudo"
-		// Add the SSH user (non-root) to the uncloud group to allow access to the Uncloud daemon unix socket.
-		env = "UNCLOUD_GROUP_ADD_USER=" + user
-	}
+
+	installCmd := installCmd(user)
 
 	fmt.Println("Downloading Uncloud install script:", installScriptURL)
-	curlBashCmd := fmt.Sprintf(
-		"curl -fsSL %s | %s %s bash", sshexec.Quote(installScriptURL), sudoPrefix, sshexec.Quote(env),
-	)
-	cmd := sshexec.QuoteCommand("bash", "-c", "set -o pipefail; "+curlBashCmd)
+
+	cmd := sshexec.QuoteCommand("bash", "-c", "set -o pipefail; "+installCmd)
 	if err = exec.Stream(ctx, cmd, os.Stdout, os.Stderr); err != nil {
 		return fmt.Errorf("download and run install script: %w", err)
 	}

internal/cli/machine_test.go

@@ -0,0 +1,19 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInstallCmd(t *testing.T) {
+	t.Run("root", func(t *testing.T) {
+		cmd := installCmd("root")
+		assert.NotContains(t, cmd, "sudo")
+	})
+
+	t.Run("nonroot", func(t *testing.T) {
+		cmd := installCmd("nonroot")
+		assert.Contains(t, cmd, "sudo")
+	})
+}

internal/corrosion/admin.go

@@ -0,0 +1,258 @@
+package corrosion
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/netip"
+	"time"
+)
+
+// AdminClient is a client for the Corrosion admin API.
+type AdminClient struct {
+	sockPath string
+}
+
+func NewAdminClient(sockPath string) (*AdminClient, error) {
+	return &AdminClient{sockPath: sockPath}, nil
+}
+
+type Response struct {
+	JSON map[string]any
+	// Err is set if the response is an error or if an error occurred while processing the response.
+	Err error
+}
+
+// SendCommand sends a command to the Corrosion admin API and returns a channel that will receive responses.
+// The channel will be closed after sending the last or error response. The caller must read from the channel until
+// it is closed.
+func (c *AdminClient) SendCommand(cmd []byte) (<-chan Response, error) {
+	conn, err := net.Dial("unix", c.sockPath)
+	if err != nil {
+		return nil, fmt.Errorf("connect to admin socket: %w", err)
+	}
+
+	if _, err = conn.Write(encodeFrame(cmd)); err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("send command: %w", err)
+	}
+
+	ch := make(chan Response)
+	go func() {
+		defer close(ch)
+		defer conn.Close()
+
+		for {
+			r := Response{}
+
+			data, err := readFrame(conn)
+			if err != nil {
+				r.Err = err
+				ch <- r
+				return
+			}
+
+			var decoded any
+			if err = json.Unmarshal(data, &decoded); err != nil {
+				r.Err = fmt.Errorf("unmarshal response: %w", err)
+				ch <- r
+				return
+			}
+
+			switch v := decoded.(type) {
+			case string:
+				if v == "Success" {
+					return
+				}
+				// Ignore other strings.
+			case map[string]any:
+				if errData, ok := v["Error"].(map[string]any); ok {
+					if errMsg, ok := errData["msg"].(string); ok {
+						r.Err = errors.New(errMsg)
+					} else {
+						r.Err = fmt.Errorf("invalid error response: %v", errData)
+					}
+					ch <- r
+					return
+				} else if jsonData, ok := v["Json"].(map[string]any); ok {
+					r.JSON = jsonData
+					ch <- r
+				}
+				// Ignore other maps.
+			default:
+				// Ignore other types.
+			}
+		}
+	}()
+
+	return ch, nil
+}
+
+// encodeFrame encodes a length_delimited Tokio frame by prefacing frame data with a frame head that specifies
+// the length of the frame.
+func encodeFrame(data []byte) []byte {
+	encoded := make([]byte, 4+len(data))
+	binary.BigEndian.PutUint32(encoded, uint32(len(data)))
+	copy(encoded[4:], data)
+	return encoded
+}
+
+// readFrame reads a length_delimited Tokio frame from the connection by extracting the frame data that follows
+// the frame head.
+func readFrame(conn net.Conn) ([]byte, error) {
+	// Read the frame head (4 bytes).
+	head := make([]byte, 4)
+	if _, err := io.ReadFull(conn, head); err != nil {
+		return nil, fmt.Errorf("read frame head: %w", err)
+	}
+	// Read the frame data (length specified in the frame head).
+	length := binary.BigEndian.Uint32(head)
+	data := make([]byte, length)
+	if _, err := io.ReadFull(conn, data); err != nil {
+		return nil, fmt.Errorf("read frame data: %w", err)
+	}
+
+	return data, nil
+}
+
+type ClusterMembershipState struct {
+	ID        string
+	Addr      netip.AddrPort
+	State     string
+	Timestamp time.Time
+}
+
+var (
+	// MembershipStateAlive indicates that the member is active.
+	MembershipStateAlive string = "Alive"
+	// MembershipStateSuspect indicates that the member is active, but at least one cluster member suspects its down.
+	// For all purposes, a Suspect member is treated as if it were Alive until either it refutes the suspicion
+	// (becoming Alive) or fails to do so (being declared Down).
+	MembershipStateSuspect string = "Suspect"
+	// MembershipStateDown indicates that the member is confirmed Down. A member that reaches this state can't join
+	// the cluster with the same identity until the cluster forgets this knowledge.
+	MembershipStateDown string = "Down"
+)
+
+func parseClusterMembershipState(json map[string]any) (ClusterMembershipState, error) {
+	// Example JSON:
+	//  {
+	//    "id": {
+	//      "addr": "[fdcc:1d51:6bae:6bb2:53c0:8796:1be0:b783]:51001",
+	//      "cluster_id": 0,
+	//      "id": "10d69d6f-6578-4dcf-a285-e860e40c5f06",
+	//      "ts": 7435936225798880256
+	//    },
+	//    "incarnation": 0,
+	//    "state": "Down"
+	//  }
+
+	var state ClusterMembershipState
+	var err error
+
+	idObj, ok := json["id"].(map[string]any)
+	if !ok {
+		return state, fmt.Errorf("missing or invalid 'id' field")
+	}
+
+	// ID
+	if id, ok := idObj["id"].(string); ok {
+		state.ID = id
+	} else {
+		return state, fmt.Errorf("missing or invalid 'id' field")
+	}
+
+	// Addr
+	if addr, ok := idObj["addr"].(string); ok {
+		state.Addr, err = netip.ParseAddrPort(addr)
+		if err != nil {
+			return state, fmt.Errorf("parse 'addr' field: %w", err)
+		}
+	} else {
+		return state, fmt.Errorf("missing or invalid 'addr' field")
+	}
+
+	// State
+	if stateStr, ok := json["state"].(string); ok {
+		switch stateStr {
+		case MembershipStateAlive, MembershipStateSuspect, MembershipStateDown:
+			state.State = stateStr
+		default:
+			return state, fmt.Errorf("invalid 'state' field: %s", stateStr)
+		}
+	} else {
+		return state, fmt.Errorf("missing or invalid 'state' field")
+	}
+
+	// Timestamp
+	if ts, ok := idObj["ts"].(float64); ok {
+		state.Timestamp = ntp64ToTime(uint64(ts))
+	} else {
+		return state, fmt.Errorf("missing or invalid 'ts' field")
+	}
+
+	return state, nil
+}
+
+// nt64ToTime converts a 64-bit NTP timestamp relative to the Unix epoch (1st Jan 1970) to time.Time.
+// See for more details: https://datatracker.ietf.org/doc/html/rfc5905#section-6
+func ntp64ToTime(ntp uint64) time.Time {
+	// The NTP timestamp returned from Corrosion is relative to the Unix epoch (1st Jan 1970)
+	// so no need to subtract the 70 years offset.
+	secs := uint32(ntp >> 32)
+	frac := uint32(ntp)
+	// Convert the fraction to nanoseconds: frac * 1e9 / 2^32
+	nsecs := (uint64(frac) * 1000_000_000) >> 32
+
+	return time.Unix(int64(secs), int64(nsecs))
+}
+
+// ClusterMembershipStates returns the current membership SWIM states of all cluster members.
+// If latest is true, only the latest state of each member is returned.
+func (c *AdminClient) ClusterMembershipStates(latest bool) ([]ClusterMembershipState, error) {
+	respCh, err := c.SendCommand([]byte("{\"Cluster\":\"MembershipStates\"}"))
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		states       []ClusterMembershipState
+		latestStates map[string]ClusterMembershipState
+		parseErr     error
+	)
+	if latest {
+		latestStates = make(map[string]ClusterMembershipState)
+	}
+
+	for r := range respCh {
+		if r.Err != nil {
+			// It's safe to return here because the channel is closed after the first error response.
+			return nil, r.Err
+		}
+
+		s, err := parseClusterMembershipState(r.JSON)
+		if err != nil {
+			// Do not return early to drain the channel.
+			parseErr = errors.Join(parseErr, err)
+		} else {
+			if latest {
+				if existing, ok := latestStates[s.ID]; !ok || existing.Timestamp.Before(s.Timestamp) {
+					latestStates[s.ID] = s
+				}
+			} else {
+				states = append(states, s)
+			}
+		}
+	}
+
+	if latest {
+		states = make([]ClusterMembershipState, 0, len(latestStates))
+		for _, s := range latestStates {
+			states = append(states, s)
+		}
+	}
+	return states, parseErr
+}

internal/corrosion/client.go

@@ -0,0 +1,233 @@
+package corrosion
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"github.com/cenkalti/backoff/v4"
+	"golang.org/x/net/http2"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/netip"
+	"net/url"
+	"time"
+)
+
+const (
+	// http2ConnectTimeout is the maximum amount of time an HTTP2 client will wait for a connection to be established.
+	http2ConnectTimeout = 3 * time.Second
+	// http2MaxRetryTime is the maximum amount of time an HTTP2 client will retry a request.
+	http2MaxRetryTime = 10 * time.Second
+	// resubscribeMaxRetryTime is the maximum amount of time an API client will retry resubscribing to a query after
+	// an error occurs.
+	resubscribeMaxRetryTime = 60 * time.Second
+)
+
+// APIClient is a client for the Corrosion API.
+type APIClient struct {
+	baseURL         *url.URL
+	client          *http.Client
+	newResubBackoff func() backoff.BackOff
+}
+
+// NewAPIClient creates a new Corrosion API client. The client retries on network errors using an exponential backoff
+// policy with a maximum interval of 1 second and a maximum elapsed time of 10 seconds.
+// It automatically resubscribes to active subscriptions if an error occurs using an exponential backoff policy with a
+// maximum interval of 1 second and a maximum elapsed time of 60 seconds.
+// Use the WithHTTP2Client option to provide a custom HTTP client and the WithResubscribeBackoff option to change the
+// backoff policy for resubscribing to a query.
+func NewAPIClient(addr netip.AddrPort, opts ...APIClientOption) (*APIClient, error) {
+	baseURL, err := url.Parse(fmt.Sprintf("http://%s", addr))
+	if err != nil {
+		return nil, fmt.Errorf("invalid URL: %w", err)
+	}
+	c := &APIClient{
+		baseURL: baseURL,
+		client: &http.Client{
+			Transport: &RetryRoundTripper{
+				Base: &http2.Transport{
+					AllowHTTP: true,
+					DialTLSContext: func(ctx context.Context, network, addr string, _ *tls.Config) (net.Conn, error) {
+						dialer := &net.Dialer{
+							Timeout: http2ConnectTimeout,
+						}
+						return dialer.DialContext(ctx, network, addr)
+					},
+				},
+				NewBackoff: func() backoff.BackOff {
+					return backoff.NewExponentialBackOff(
+						backoff.WithInitialInterval(100*time.Millisecond),
+						backoff.WithMaxInterval(1*time.Second),
+						backoff.WithMaxElapsedTime(http2MaxRetryTime),
+					)
+				},
+			},
+		},
+		newResubBackoff: func() backoff.BackOff {
+			return backoff.NewExponentialBackOff(
+				backoff.WithInitialInterval(100*time.Millisecond),
+				backoff.WithMaxInterval(1*time.Second),
+				backoff.WithMaxElapsedTime(resubscribeMaxRetryTime),
+			)
+		},
+	}
+
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c, nil
+}
+
+type APIClientOption func(*APIClient)
+
+func WithHTTP2Client(client *http.Client) APIClientOption {
+	return func(c *APIClient) {
+		c.client = client
+	}
+}
+
+// WithResubscribeBackoff sets the backoff policy for resubscribing to a query if an error occurs.
+// Pass nil to disable resubscribing.
+func WithResubscribeBackoff(newBackoff func() backoff.BackOff) APIClientOption {
+	return func(c *APIClient) {
+		c.newResubBackoff = newBackoff
+	}
+}
+
+type RetryRoundTripper struct {
+	Base http.RoundTripper
+	// NewBackoff creates a new backoff policy for each request.
+	NewBackoff func() backoff.BackOff
+}
+
+func (rt *RetryRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	roundTrip := func() (*http.Response, error) {
+		resp, err := rt.Base.RoundTrip(req)
+		if err != nil {
+			var opErr *net.OpError
+			if errors.As(err, &opErr) {
+				// Not certain, but I expect operational errors should generally be retryable.
+				slog.Debug("Retrying corrosion API request due to network error.", "error", err)
+				return nil, err
+			}
+			// Don't retry on other errors.
+			return nil, backoff.Permanent(err)
+		}
+		// Success, don't retry.
+		return resp, err
+	}
+	boff := backoff.WithContext(rt.NewBackoff(), req.Context())
+	return backoff.RetryWithData(roundTrip, boff)
+}
+
+type RetrySubscription struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	client       *APIClient
+	sub          *Subscription
+	changes      chan *ChangeEvent
+	lastChangeID uint64
+	err          error
+	backoff      backoff.BackOff
+}
+
+func NewRetrySubscription(ctx context.Context, client *APIClient, sub *Subscription, boff backoff.BackOff) *RetrySubscription {
+	ctx, cancel := context.WithCancel(ctx)
+	if boff == nil {
+		boff = backoff.NewExponentialBackOff(
+			backoff.WithInitialInterval(100*time.Millisecond),
+			backoff.WithMaxInterval(1*time.Second),
+			backoff.WithMaxElapsedTime(60*time.Second),
+		)
+	}
+	return &RetrySubscription{
+		ctx:     ctx,
+		cancel:  cancel,
+		client:  client,
+		sub:     sub,
+		backoff: backoff.WithContext(boff, ctx),
+	}
+}
+
+func (rs *RetrySubscription) ID() string {
+	return rs.sub.ID()
+}
+
+func (rs *RetrySubscription) Changes() (<-chan *ChangeEvent, error) {
+	if rs.changes != nil {
+		return rs.changes, nil
+	}
+
+	// Ensure the rows are consumed if they have been requested.
+	changes, err := rs.sub.Changes()
+	if err != nil {
+		return nil, err
+	}
+	rs.lastChangeID = rs.sub.lastChangeID
+
+	go func() {
+		defer close(rs.changes)
+
+		var change *ChangeEvent
+		for {
+			select {
+			case change = <-changes:
+			case <-rs.ctx.Done():
+				return
+			}
+
+			if change != nil {
+				select {
+				case rs.changes <- change:
+				case <-rs.ctx.Done():
+					return
+				}
+				rs.lastChangeID = change.ChangeID
+				continue
+			}
+
+			// The underlying subscription has been closed due to an error or context cancellation.
+			// Return if the context is done or try to resubscribe otherwise.
+			if rs.ctx.Err() != nil {
+				return
+			}
+
+			if err = rs.resubscribe(); err != nil {
+				// resubscribe returns a permanent error after unsuccessful retries.
+				rs.err = fmt.Errorf("resubscribe to query: %w", err)
+				return
+			}
+			changes, err = rs.sub.Changes()
+			if err != nil {
+				// Unexpected error but report it anyway.
+				rs.err = err
+				return
+			}
+		}
+	}()
+
+	return rs.changes, nil
+}
+
+func (rs *RetrySubscription) resubscribe() error {
+	return backoff.Retry(func() error {
+		slog.Debug("Resubscribing to Corrosion query.", "id", rs.ID(), "from_change", rs.lastChangeID)
+		sub, err := rs.client.ResubscribeContext(rs.ctx, rs.ID(), rs.lastChangeID)
+		if err != nil {
+			return err
+		}
+		rs.sub = sub
+		return nil
+	}, rs.backoff)
+}
+
+func (rs *RetrySubscription) Err() error {
+	return rs.err
+}
+
+func (rs *RetrySubscription) Close() {
+	rs.cancel()
+}

internal/corrosion/query.go

@@ -0,0 +1,327 @@
+package corrosion
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+type Statement struct {
+	Query  string `json:"query"`
+	Params []any  `json:"params"`
+}
+
+type ExecResponse struct {
+	Results []ExecResult `json:"results"`
+	Time    float64      `json:"time"`
+	Version *uint        `json:"version"`
+}
+
+type ExecResult struct {
+	RowsAffected uint    `json:"rows_affected"`
+	Time         float64 `json:"time"`
+	Error        *string `json:"error"`
+}
+
+// ExecContext writes changes to the Corrosion database for propagation through the cluster. The args are for any
+// placeholder parameters in the query. Corrosion does not sync schema changes made using this method. Use Corrosion's
+// schema_files to create and update the cluster's database schema.
+func (c *APIClient) ExecContext(ctx context.Context, query string, args ...any) (*ExecResult, error) {
+	statements := []Statement{
+		{
+			Query:  query,
+			Params: args,
+		},
+	}
+	resp, err := c.ExecMultiContext(ctx, statements...)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(resp.Results) == 0 {
+		return nil, fmt.Errorf("no results: %+v", resp)
+	}
+	return &resp.Results[0], nil
+}
+
+// ExecMultiContext writes changes to the Corrosion database for propagation through the cluster.
+// Unlike ExecContext, this method allows multiple statements to be executed in a single transaction.
+func (c *APIClient) ExecMultiContext(ctx context.Context, statements ...Statement) (*ExecResponse, error) {
+	body, err := json.Marshal(statements)
+	if err != nil {
+		return nil, fmt.Errorf("marshal queries: %w", err)
+	}
+
+	transactionsURL := c.baseURL.JoinPath("/v1/transactions").String()
+	req, err := http.NewRequestWithContext(ctx, "POST", transactionsURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var execResp ExecResponse
+	if resp.StatusCode == http.StatusOK {
+		if err = json.NewDecoder(resp.Body).Decode(&execResp); err != nil {
+			return nil, fmt.Errorf("decode response: %w", err)
+		}
+		// The response may still contain DB errors even if the status code is OK. Return them along with the response.
+		var errs []error
+		for _, result := range execResp.Results {
+			if result.Error != nil {
+				errs = append(errs, errors.New(*result.Error))
+			}
+		}
+		return &execResp, errors.Join(errs...)
+	} else if resp.StatusCode == http.StatusInternalServerError {
+		// If the response is an Internal Server Error, the response body may contain the error encoded as ExecResponse.
+		respBody, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("read response body: %w", err)
+		}
+		if err = json.Unmarshal(respBody, &execResp); err != nil {
+			return nil, fmt.Errorf("internal server error: %s", respBody)
+		}
+		if len(execResp.Results) > 0 && execResp.Results[0].Error != nil {
+			return nil, errors.New(*execResp.Results[0].Error)
+		}
+		return nil, fmt.Errorf("internal server error: %s", respBody)
+	}
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read response body: %w", err)
+	}
+	return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, respBody)
+}
+
+type QueryEvent struct {
+	Columns []string     `json:"columns"`
+	Row     *RowEvent    `json:"row"`
+	EOQ     *EndOfQuery  `json:"eoq"`
+	Change  *ChangeEvent `json:"change"`
+	// Error is a server-side error that occurred during query execution. It's considered fatal for the client
+	// as it cannot be recovered from server-side.
+	Error *string `json:"error"`
+}
+
+type EndOfQuery struct {
+	Time     float64 `json:"time"`
+	ChangeID *uint64 `json:"change_id"`
+}
+
+type RowEvent struct {
+	RowID  uint64
+	Values []json.RawMessage
+}
+
+func (re *RowEvent) UnmarshalJSON(data []byte) error {
+	var raw []json.RawMessage
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return fmt.Errorf("invalid row event: %w", err)
+	}
+	if len(raw) != 2 {
+		return fmt.Errorf("invalid row event: expected an array of 2 elements")
+	}
+	if err := json.Unmarshal(raw[0], &re.RowID); err != nil {
+		return fmt.Errorf("invalid row event: %w", err)
+	}
+	if err := json.Unmarshal(raw[1], &re.Values); err != nil {
+		return fmt.Errorf("invalid row event: %w", err)
+	}
+	return nil
+}
+
+func (re *RowEvent) MarshalJSON() ([]byte, error) {
+	return json.Marshal([]any{re.RowID, re.Values})
+}
+
+// QueryContext executes a query that returns rows, typically a SELECT.
+// The args are for any placeholder parameters in the query.
+func (c *APIClient) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
+	statement := Statement{
+		Query:  query,
+		Params: args,
+	}
+	body, err := json.Marshal(statement)
+	if err != nil {
+		return nil, fmt.Errorf("marshal query: %w", err)
+	}
+
+	queriesURL := c.baseURL.JoinPath("/v1/queries").String()
+	req, err := http.NewRequestWithContext(ctx, "POST", queriesURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("send request: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			return nil, fmt.Errorf("read response body: %w", err)
+		}
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, respBody)
+	}
+
+	rows, err := newRows(ctx, resp.Body, true)
+	if err != nil {
+		resp.Body.Close()
+		return nil, fmt.Errorf("parse query response: %w", err)
+	}
+	return rows, nil
+}
+
+// Rows is the result of a query. Its cursor starts before the first row of the result set.
+// Use [Rows.Next] to advance from row to row.
+type Rows struct {
+	ctx        context.Context
+	body       io.ReadCloser
+	decoder    *json.Decoder
+	eoq        *EndOfQuery
+	closeOnEOQ bool
+
+	columns []string
+	row     RowEvent
+	err     error
+}
+
+func newRows(ctx context.Context, body io.ReadCloser, closeOnEOQ bool) (*Rows, error) {
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	default:
+	}
+
+	decoder := json.NewDecoder(body)
+	var e QueryEvent
+	if err := decoder.Decode(&e); err != nil {
+		return nil, fmt.Errorf("decode query event: %w", err)
+	}
+	if e.Columns == nil {
+		return nil, fmt.Errorf("expected columns event, got: %+v", e)
+	}
+
+	return &Rows{
+		ctx:        ctx,
+		body:       body,
+		decoder:    decoder,
+		closeOnEOQ: closeOnEOQ,
+		columns:    e.Columns,
+	}, nil
+}
+
+// Columns returns the column names.
+func (rs *Rows) Columns() []string {
+	return rs.columns
+}
+
+// Next prepares the next result row for reading with the [Rows.Scan] method. It returns true on success, or false
+// if there is no next result row or an error happened while preparing it. [Rows.Err] should be consulted to distinguish
+// between the two cases.
+//
+// Every call to [Rows.Scan], even the first one, must be preceded by a call to [Rows.Next].
+func (rs *Rows) Next() bool {
+	select {
+	case <-rs.ctx.Done():
+		rs.err = rs.ctx.Err()
+		_ = rs.Close()
+		return false
+	default:
+	}
+
+	var e QueryEvent
+	if err := rs.decoder.Decode(&e); err != nil {
+		rs.err = fmt.Errorf("decode query event: %w", err)
+		_ = rs.Close()
+		return false
+	}
+	// Server-side query error.
+	if e.Error != nil {
+		rs.err = fmt.Errorf("query error: %s", *e.Error)
+		_ = rs.Close()
+		return false
+	}
+
+	if e.Row != nil {
+		if len(e.Row.Values) != len(rs.columns) {
+			rs.err = fmt.Errorf("expected %d column values, got %d", len(rs.columns), len(e.Row.Values))
+			_ = rs.Close()
+			return false
+		}
+		rs.row = *e.Row
+		return true
+	}
+	if e.EOQ != nil {
+		rs.eoq = e.EOQ
+		// Rows could be used as part of a subscription, so don't close the body if so.
+		if rs.closeOnEOQ {
+			_ = rs.Close()
+		}
+		return false
+	}
+
+	rs.err = fmt.Errorf("expected row or eof event, got: %+v", e)
+	_ = rs.Close()
+	return false
+}
+
+// Err returns the error, if any, that was encountered during iteration.
+// Err may be called after an explicit or implicit [Rows.Close].
+func (rs *Rows) Err() error {
+	return rs.err
+}
+
+// Scan copies the columns in the current row into the values pointed at by dest.
+// The number of values in dest must be the same as the number of columns in [Rows].
+// Scan converts JSON-encoded column values to the provided Go types using [json.Unmarshal].
+func (rs *Rows) Scan(dest ...any) error {
+	if rs.err != nil {
+		return rs.err
+	}
+	if len(dest) != len(rs.columns) {
+		return fmt.Errorf("expected %d values, got %d", len(rs.columns), len(dest))
+	}
+
+	for i, v := range rs.row.Values {
+		if err := json.Unmarshal(v, dest[i]); err != nil {
+			return fmt.Errorf("unmarshal column value #%d: %w", i, err)
+		}
+	}
+	return nil
+}
+
+// Time returns the time taken to execute the query in seconds. It's only available after all rows have been consumed.
+// It doesn't include the time to send the query, receive the response, or iterate over the rows.
+func (rs *Rows) Time() (float64, error) {
+	if rs.eoq == nil {
+		if rs.Err() != nil {
+			return 0, fmt.Errorf("time is not available: %w", rs.Err())
+		}
+		return 0, errors.New("time is not available until all rows are consumed")
+	}
+	return rs.eoq.Time, nil
+}
+
+// Close closes the [Rows], preventing further enumeration. If [Rows.Next] is called and returns false,
+// the [Rows] are closed automatically and it will suffice to check the result of [Rows.Err].
+// Close is idempotent and does not affect the result of [Rows.Err].
+func (rs *Rows) Close() error {
+	return rs.body.Close()
+}

internal/corrosion/subscribe.go

@@ -0,0 +1,323 @@
+package corrosion
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/cenkalti/backoff/v4"
+	"io"
+	"log/slog"
+	"net/http"
+	"strconv"
+)
+
+type ChangeType string
+
+var (
+	ChangeTypeInsert ChangeType = "insert"
+	ChangeTypeUpdate ChangeType = "update"
+	ChangeTypeDelete ChangeType = "delete"
+)
+
+type ChangeEvent struct {
+	Type     ChangeType
+	RowID    uint64
+	Values   []json.RawMessage
+	ChangeID uint64
+}
+
+func (ce *ChangeEvent) UnmarshalJSON(data []byte) error {
+	var raw []json.RawMessage
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return fmt.Errorf("invalid change event: %w", err)
+	}
+	if len(raw) != 4 {
+		return fmt.Errorf("invalid change event: expected an array of 4 elements")
+	}
+	if err := json.Unmarshal(raw[0], &ce.Type); err != nil {
+		return fmt.Errorf("invalid change event type: %w", err)
+	}
+	if err := json.Unmarshal(raw[1], &ce.RowID); err != nil {
+		return fmt.Errorf("invalid change event row ID: %w", err)
+	}
+	if err := json.Unmarshal(raw[2], &ce.Values); err != nil {
+		return fmt.Errorf("invalid change event values: %w", err)
+	}
+	if err := json.Unmarshal(raw[3], &ce.ChangeID); err != nil {
+		return fmt.Errorf("invalid change event change ID: %w", err)
+	}
+	return nil
+}
+
+func (ce *ChangeEvent) MarshalJSON() ([]byte, error) {
+	return json.Marshal([]any{ce.Type, ce.RowID, ce.Values, ce.ChangeID})
+}
+
+// Scan copies the column values in the change event into the values pointed at by dest.
+// The number of values in dest must be the same as the number of columns in the change.
+// Scan converts JSON-encoded column values to the provided Go types using [json.Unmarshal].
+func (ce *ChangeEvent) Scan(dest ...any) error {
+	if len(dest) != len(ce.Values) {
+		return fmt.Errorf("expected %d values, got %d", len(ce.Values), len(dest))
+	}
+
+	for i, v := range ce.Values {
+		if err := json.Unmarshal(v, dest[i]); err != nil {
+			return fmt.Errorf("unmarshal column value #%d: %w", i, err)
+		}
+	}
+	return nil
+}
+
+// Subscription receives updates from the Corrosion database for a desired SQL query.
+type Subscription struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	id           string
+	rows         *Rows
+	body         io.ReadCloser
+	decoder      *json.Decoder
+	resubscribe  func(ctx context.Context, fromChange uint64) (*Subscription, error)
+	changes      chan *ChangeEvent
+	lastChangeID uint64
+	err          error
+}
+
+func newSubscription(
+	ctx context.Context,
+	id string,
+	rows *Rows,
+	body io.ReadCloser,
+	decoder *json.Decoder,
+	resubscribe func(ctx context.Context, fromChange uint64) (*Subscription, error),
+) *Subscription {
+	ctx, cancel := context.WithCancel(ctx)
+	if decoder == nil {
+		decoder = json.NewDecoder(body)
+	}
+	return &Subscription{
+		ctx:         ctx,
+		cancel:      cancel,
+		id:          id,
+		rows:        rows,
+		body:        body,
+		decoder:     decoder,
+		resubscribe: resubscribe,
+	}
+}
+
+// ID returns the subscription ID.
+func (s *Subscription) ID() string {
+	return s.id
+}
+
+// Rows returns the rows of the query or nil if skipRows was true when creating the subscription or if the subscription
+// was created with [APIClient.ResubscribeContext].
+func (s *Subscription) Rows() *Rows {
+	return s.rows
+}
+
+// Changes returns a channel that receives change events for the query. Changes are not available until all rows
+// are consumed. The channel is closed when the context is done, or an error occurs while reading the changes,
+// or when the subscription is closed explicitly. If it's closed due to an error, [Subscription.Err] will return
+// the error.
+func (s *Subscription) Changes() (<-chan *ChangeEvent, error) {
+	if s.changes != nil {
+		return s.changes, nil
+	}
+
+	if s.rows != nil {
+		if s.rows.eoq == nil {
+			return nil, errors.New("changes are not available until all rows are consumed")
+		}
+		s.lastChangeID = *s.rows.eoq.ChangeID
+	}
+	s.changes = make(chan *ChangeEvent)
+
+	go func() {
+		// Close the body when the context is done to unblock the decoder in the following goroutine.
+		<-s.ctx.Done()
+		s.body.Close()
+	}()
+	go s.handleChangeEvents()
+
+	return s.changes, nil
+}
+
+func (s *Subscription) handleChangeEvents() {
+	defer s.cancel()
+	defer close(s.changes)
+
+	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		default:
+		}
+
+		var e QueryEvent
+		var err error
+		if err = s.decoder.Decode(&e); err != nil {
+			// Do not report an error that occurred due to context cancellation, just return.
+			if s.ctx.Err() != nil {
+				return
+			}
+			err = fmt.Errorf("decode query event: %w", err)
+		} else if e.Error != nil {
+			err = fmt.Errorf("query error: %s", *e.Error)
+		} else if e.Change == nil {
+			err = fmt.Errorf("expected change event, got: %+v", e)
+		} else if s.lastChangeID != 0 && e.Change.ChangeID != s.lastChangeID+1 {
+			// If skipRows is true, the last change ID is unknown.
+			err = fmt.Errorf("missed a change: expected change ID %d, got %d",
+				s.lastChangeID+1, e.Change.ChangeID)
+		}
+
+		if err == nil {
+			s.lastChangeID = e.Change.ChangeID
+			select {
+			case s.changes <- e.Change:
+			case <-s.ctx.Done():
+				return
+			}
+		} else {
+			// Report the error if resubscribing is disabled.
+			if s.resubscribe == nil {
+				s.err = err
+				return
+			}
+
+			slog.Info("Resubscribing to Corrosion query due to an error.",
+				"err", err, "id", s.id, "from_change", s.lastChangeID)
+			sub, sErr := s.resubscribe(s.ctx, s.lastChangeID)
+			if sErr != nil {
+				// resubscribe returns a permanent error after unsuccessful retries.
+				s.err = fmt.Errorf("resubscribe to query with backoff: %w", sErr)
+				return
+			}
+			// Reset the subscription to the new one.
+			s.rows = nil
+			s.body = sub.body
+			s.decoder = sub.decoder
+			// Do not close the sub to not close the body.
+			sub.cancel()
+		}
+	}
+}
+
+// Err returns the error, if any, that was encountered during fetching changes.
+// Err may be called after an explicit or implicit [Subscription.Close].
+func (s *Subscription) Err() error {
+	return s.err
+}
+
+func (s *Subscription) Close() error {
+	s.cancel()
+	return s.body.Close()
+}
+
+// SubscribeContext creates a subscription to receive updates for a desired SQL query. If skipRows is false,
+// Subscription.Rows must be consumed before Subscription.Changes can be called. If skipRows is true, Subscription.Rows
+// will return nil.
+func (c *APIClient) SubscribeContext(
+	ctx context.Context, query string, args []any, skipRows bool,
+) (*Subscription, error) {
+	statement := Statement{
+		Query:  query,
+		Params: args,
+	}
+	body, err := json.Marshal(statement)
+	if err != nil {
+		return nil, fmt.Errorf("marshal query: %w", err)
+	}
+
+	subURL := c.baseURL.JoinPath("/v1/subscriptions")
+	if skipRows {
+		q := subURL.Query()
+		q.Set("skip_rows", "true")
+		subURL.RawQuery = q.Encode()
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", subURL.String(), bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("send request: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			return nil, fmt.Errorf("read response body: %w", err)
+		}
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, respBody)
+	}
+
+	id := resp.Header.Get("corro-query-id")
+	if id == "" {
+		resp.Body.Close()
+		return nil, errors.New("missing corro-query-id header in response")
+	}
+
+	if skipRows {
+		return newSubscription(ctx, id, nil, resp.Body, nil, c.resubscribeWithBackoffFn(id)), nil
+	}
+
+	rows, err := newRows(ctx, resp.Body, false)
+	if err != nil {
+		resp.Body.Close()
+		return nil, fmt.Errorf("parse query response: %w", err)
+	}
+	return newSubscription(ctx, id, rows, rows.body, rows.decoder, c.resubscribeWithBackoffFn(id)), nil
+}
+
+func (c *APIClient) resubscribeWithBackoffFn(id string) func(context.Context, uint64) (*Subscription, error) {
+	if c.newResubBackoff == nil {
+		return nil
+	}
+	return func(ctx context.Context, fromChange uint64) (*Subscription, error) {
+		return backoff.RetryWithData(func() (*Subscription, error) {
+			slog.Debug("Retrying to resubscribe to Corrosion query.", "id", id, "from_change", fromChange)
+			return c.ResubscribeContext(ctx, id, fromChange)
+		}, c.newResubBackoff())
+	}
+}
+
+func (c *APIClient) ResubscribeContext(ctx context.Context, id string, fromChange uint64) (*Subscription, error) {
+	subURL := c.baseURL.JoinPath("/v1/subscriptions", id)
+	q := subURL.Query()
+	q.Set("from", strconv.FormatUint(fromChange, 10))
+	subURL.RawQuery = q.Encode()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", subURL.String(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("send request: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			return nil, fmt.Errorf("read response body: %w", err)
+		}
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, respBody)
+	}
+
+	return newSubscription(ctx, id, nil, resp.Body, nil, c.resubscribeWithBackoffFn(id)), nil
+}

internal/daemon/daemon.go

@@ -35,7 +35,7 @@ func (d *Daemon) Run(ctx context.Context) error {
 		case <-d.machine.Started():
 			_, err := systemd.SdNotify(false, systemd.SdNotifyReady)
 			if err != nil {
-				slog.Error("Failed to notify systemd that the daemon is ready.", "error", err)
+				slog.Error("Failed to notify systemd that the daemon is ready.", "err", err)
 			}
 		case <-ctx.Done():
 		}

internal/daemon/token.go

@@ -37,5 +37,5 @@ func MachineToken(dataDir string) (machine.Token, error) {
 	for i, ip := range ips {
 		endpoints[i] = netip.AddrPortFrom(ip, network.WireGuardPort)
 	}
-	return machine.NewToken(state.Network.PublicKey, endpoints), nil
+	return machine.NewToken(state.Network.PublicKey, publicIP, endpoints), nil
 }

internal/dns/api.go

@@ -0,0 +1,34 @@
+package dns
+
+const (
+	RecordTypeA    RecordType = "A"
+	RecordTypeAAAA RecordType = "AAAA"
+)
+
+type RecordType string
+
+type DomainResponse struct {
+	Name  string `json:"name,omitempty"`
+	Token string `json:"token,omitempty"`
+}
+
+type RecordRequest struct {
+	Name   string     `json:"name,omitempty"`
+	Type   RecordType `json:"type,omitempty"`
+	Values []string   `json:"values,omitempty"`
+}
+
+type RecordResponse struct {
+	RecordRequest
+	FQDN string `json:"fqdn,omitempty"`
+}
+
+type AuthErrorResponse struct {
+	Status  int           `json:"status,omitempty"`
+	Message string        `json:"msg,omitempty"`
+	Data    authErrorData `json:"data,omitempty"`
+}
+
+type authErrorData struct {
+	NoDomain bool `json:"noDomain,omitempty"`
+}

internal/dns/client.go

@@ -0,0 +1,152 @@
+package dns
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+)
+
+// The dns package code is based on https://github.com/acorn-io/runtime/blob/main/pkg/dns.
+
+// Client handles interactions with the Uncloud DNS API service.
+type Client interface {
+	// ReserveDomain calls Uncloud DNS to reserve a new domain. It returns the domain, a token for authentication,
+	// and an error.
+	ReserveDomain(endpoint string) (string, string, error)
+
+	// CreateRecords calls Uncloud DNS to create or update DNS records based on the supplied RecordRequests
+	// for the specified domain.
+	CreateRecords(endpoint, domain, token string, records []RecordRequest) ([]RecordResponse, error)
+}
+
+// ErrAuthNoDomain indicates that a request failed authentication because the domain was not found.
+// If encountered, a new domain needs to be reserved.
+var ErrAuthNoDomain = errors.New("the supplied domain failed authentication")
+
+// NewClient creates a new AcornDNS client
+func NewClient() Client {
+	return &client{
+		c: http.DefaultClient,
+	}
+}
+
+type client struct {
+	c *http.Client
+}
+
+func (c *client) ReserveDomain(endpoint string) (string, string, error) {
+	url := fmt.Sprintf("%s/%s", endpoint, "domains")
+
+	req, err := c.request(http.MethodPost, url, nil, "")
+	if err != nil {
+		return "", "", err
+	}
+
+	resp := &DomainResponse{}
+	err = c.do(req, resp)
+	if err != nil {
+		return "", "", err
+	}
+
+	return resp.Name, resp.Token, nil
+}
+
+func (c *client) CreateRecords(endpoint, domain, token string, records []RecordRequest) ([]RecordResponse, error) {
+	url := fmt.Sprintf("%s/domains/%s/records", endpoint, domain)
+
+	var resp []RecordResponse
+	for _, recordRequest := range records {
+		body, err := jsonBody(recordRequest)
+		if err != nil {
+			return resp, err
+		}
+
+		req, err := c.request(http.MethodPost, url, body, token)
+		if err != nil {
+			return resp, err
+		}
+
+		var recordResp RecordResponse
+		if err = c.do(req, &recordResp); err != nil {
+			return resp, err
+		}
+		resp = append(resp, recordResp)
+	}
+
+	return resp, nil
+}
+
+func (c *client) request(method string, url string, body io.Reader, token string) (*http.Request, error) {
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("Content-Type", "application/json")
+
+	if token != "" {
+		bearer := "Bearer " + token
+		req.Header.Add("Authorization", bearer)
+	}
+
+	return req, nil
+}
+
+func (c *client) do(req *http.Request, responseBody any) error {
+	slog.Debug("Making request to DNS service.", "method", req.Method, "url", req.URL)
+
+	resp, err := c.c.Do(req)
+	if err != nil {
+		return err
+	}
+
+	slog.Debug("Response code for request to DNS service.",
+		"method", req.Method, "url", req.URL, "code", resp.StatusCode)
+	// When err is nil, resp contains a non-nil resp.Body which must be closed.
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("read response body: %w", err)
+	}
+
+	if resp.StatusCode == http.StatusUnauthorized {
+		var authError AuthErrorResponse
+
+		err = json.Unmarshal(body, &authError)
+		if err != nil {
+			return fmt.Errorf("unmarshal auth error response: %w", err)
+		}
+
+		if authError.Data.NoDomain {
+			return ErrAuthNoDomain
+		}
+
+		return errors.New("authentication failed")
+	}
+
+	if code := resp.StatusCode; code < 200 || code > 300 {
+		return fmt.Errorf("unexpected response status code: %d", code)
+	}
+
+	if responseBody != nil {
+		err = json.Unmarshal(body, responseBody)
+		if err != nil {
+			return fmt.Errorf("unmarshal response body (%s): %w", string(body), err)
+		}
+	}
+
+	return nil
+}
+
+func jsonBody(payload any) (io.Reader, error) {
+	buf := &bytes.Buffer{}
+	err := json.NewEncoder(buf).Encode(payload)
+	if err != nil {
+		return nil, err
+	}
+	return buf, nil
+}

internal/docker/client.go

@@ -0,0 +1,49 @@
+package docker
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/cenkalti/backoff/v4"
+	"github.com/docker/docker/client"
+	"log/slog"
+	"time"
+)
+
+// WaitDaemonReady waits for the Docker daemon to start and be ready to serve requests.
+func WaitDaemonReady(ctx context.Context, cli *client.Client) error {
+	// Retry to ping the Docker daemon until it's ready or the context is canceled.
+	boff := backoff.WithContext(backoff.NewExponentialBackOff(
+		backoff.WithInitialInterval(100*time.Millisecond),
+		backoff.WithMaxInterval(1*time.Second),
+		backoff.WithMaxElapsedTime(0),
+	), ctx)
+
+	waitingLogged := false
+	ping := func() error {
+		_, err := cli.Ping(ctx)
+		if err == nil {
+			if waitingLogged {
+				slog.Info("Docker daemon is ready.")
+			}
+			return nil
+		}
+		if !client.IsErrConnectionFailed(err) {
+			return backoff.Permanent(fmt.Errorf("connect to Docker daemon: %w", err))
+		}
+
+		if !waitingLogged {
+			slog.Info("Waiting for Docker daemon to start and be ready.")
+			waitingLogged = true
+		}
+		return err
+	}
+
+	if err := backoff.Retry(ping, boff); err != nil {
+		if errors.Is(err, context.Canceled) {
+			return nil
+		}
+		return fmt.Errorf("ping Docker: %w", err)
+	}
+	return nil
+}

internal/fs/fs.go

@@ -0,0 +1,73 @@
+package fs
+
+import (
+	"fmt"
+	"os"
+	"os/user"
+	"strconv"
+	"strings"
+)
+
+func ExpandHomeDir(path string) string {
+	if len(path) == 0 {
+		return path
+	}
+	if path[0] == '~' {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return path
+		}
+		return strings.Replace(path, "~", home, 1)
+	}
+	return path
+}
+
+// LookupUIDGID returns the user and group IDs for the given username.
+func LookupUIDGID(username string) (uid, gid int, err error) {
+	usr, err := user.Lookup(username)
+	if err != nil {
+		err = fmt.Errorf("lookup user %q: %w", username, err)
+		return
+	}
+	uid, err = strconv.Atoi(usr.Uid)
+	if err != nil {
+		err = fmt.Errorf("parse %q user ID (UID) %q: %w", username, usr.Uid, err)
+		return
+	}
+	gid, err = strconv.Atoi(usr.Gid)
+	if err != nil {
+		err = fmt.Errorf("parse %q user group ID (GID) %q: %w", username, usr.Gid, err)
+		return
+	}
+	return
+}
+
+func Chown(path, username, group string) error {
+	uid, gid := -1, -1
+	if username != "" {
+		usr, err := user.Lookup(username)
+		if err != nil {
+			return fmt.Errorf("lookup user %q: %w", username, err)
+		}
+		uid, err = strconv.Atoi(usr.Uid)
+		if err != nil {
+			return fmt.Errorf("parse %q user ID (UID) %q: %w", username, usr.Uid, err)
+		}
+	}
+
+	if group != "" {
+		grp, err := user.LookupGroup(group)
+		if err != nil {
+			return fmt.Errorf("lookup group %q: %w", group, err)
+		}
+		gid, err = strconv.Atoi(grp.Gid)
+		if err != nil {
+			return fmt.Errorf("parse %q group ID (GID) %q: %w", group, grp.Gid, err)
+		}
+	}
+
+	if err := os.Chown(path, uid, gid); err != nil {
+		return fmt.Errorf("chown %q: %w", path, err)
+	}
+	return nil
+}

internal/fs/fs_test.go

@@ -0,0 +1,22 @@
+package fs
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExpandHomeDir(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		assert.Equal(t, "", ExpandHomeDir(""))
+	})
+
+	t.Run("no home", func(t *testing.T) {
+		assert.Equal(t, "/path", ExpandHomeDir("/path"))
+	})
+
+	t.Run("home", func(t *testing.T) {
+		t.Setenv("HOME", "/home/user")
+		assert.Equal(t, "/home/user/path", ExpandHomeDir("~/path"))
+	})
+}

internal/log/handler.go

@@ -0,0 +1,74 @@
+package log
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log/slog"
+	"sync"
+)
+
+// SlogTextHandler extends the standard [slog.TextHandler] to provide custom formatting that is very similar
+// to the default slog handler. It prefixes each log entry with a right-padded level indicator and message,
+// while excluding the default time, level, and message attributes from the structured output.
+//
+// The output format is:
+// LEVEL MESSAGE key1=value1 key2=value2
+type SlogTextHandler struct {
+	*slog.TextHandler
+	opts slog.HandlerOptions
+	mu   sync.Mutex
+	w    io.Writer
+}
+
+func NewSlogTextHandler(w io.Writer, opts *slog.HandlerOptions) *SlogTextHandler {
+	if opts == nil {
+		opts = &slog.HandlerOptions{}
+	}
+	// Remove time, level, and message from the default attributes.
+	opts.ReplaceAttr = func(groups []string, a slog.Attr) slog.Attr {
+		if a.Key == slog.TimeKey || a.Key == slog.LevelKey || a.Key == slog.MessageKey {
+			return slog.Attr{}
+		}
+		return a
+	}
+
+	return &SlogTextHandler{
+		TextHandler: slog.NewTextHandler(w, opts),
+		opts:        *opts,
+		w:           w,
+	}
+}
+
+func (h *SlogTextHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	return h.TextHandler.Enabled(ctx, level)
+}
+
+func (h *SlogTextHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return h.TextHandler.WithAttrs(attrs)
+}
+
+func (h *SlogTextHandler) WithGroup(name string) slog.Handler {
+	return h.TextHandler.WithGroup(name)
+}
+
+func (h *SlogTextHandler) Handle(ctx context.Context, r slog.Record) error {
+	// Only log entries that are at or above the minimum level (INFO by default).
+	minLevel := slog.LevelInfo
+	if h.opts.Level != nil {
+		minLevel = h.opts.Level.Level()
+	}
+	if r.Level < minLevel {
+		return nil
+	}
+
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	levelMsg := fmt.Sprintf("%-5s %s ", r.Level.String(), r.Message)
+	if _, err := h.w.Write([]byte(levelMsg)); err != nil {
+		return err
+	}
+
+	return h.TextHandler.Handle(ctx, r)
+}

internal/machine/api/pb/cluster.go

@@ -1,7 +1,6 @@
 package pb
 
 import (
-	"fmt"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -40,10 +39,3 @@ func (c *NetworkConfig) Validate() error {
 
 	return nil
 }
-
-func (r *AddMachineRequest) Validate() error {
-	if r.Network == nil {
-		return fmt.Errorf("network not set")
-	}
-	return r.Network.Validate()
-}

internal/machine/api/pb/cluster.proto

@@ -6,62 +6,73 @@ option go_package = "github.com/psviderski/uncloud/internal/machine/api/pb";
 
 import "google/protobuf/empty.proto";
 import "internal/machine/api/pb/common.proto";
+import "internal/machine/api/pb/machine.proto";
 
 service Cluster {
   rpc AddMachine(AddMachineRequest) returns (AddMachineResponse);
   rpc ListMachines(google.protobuf.Empty) returns (ListMachinesResponse);
-  rpc ListMachineEndpoints(ListMachineEndpointsRequest) returns (ListMachineEndpointsResponse);
+
+  rpc ReserveDomain(ReserveDomainRequest) returns (Domain);
+  rpc GetDomain(google.protobuf.Empty) returns (Domain);
+  rpc ReleaseDomain(google.protobuf.Empty) returns (Domain);
+  rpc CreateDomainRecords(CreateDomainRecordsRequest) returns (CreateDomainRecordsResponse);
 }
 
 message AddMachineRequest {
   string name = 1;
   NetworkConfig network = 2;
+  IP public_ip = 3;
 }
 
 message AddMachineResponse {
   MachineInfo machine = 1;
 }
 
+message MachineMember {
+  MachineInfo machine = 1;
+
+  enum MembershipState {
+    UNKNOWN = 0;
+    // The member is active.
+    UP = 1;
+    // The member is active, but at least one cluster member suspects its down. For all purposes,
+    // a SUSPECT member is treated as if it were UP until either it refutes the suspicion (becoming UP)
+    // or fails to do so (being declared DOWN).
+    SUSPECT = 2;
+    // The member is confirmed DOWN.
+    DOWN = 3;
+  }
+  MembershipState state = 2;
+}
+
 message ListMachinesResponse {
-  repeated MachineInfo machines = 1;
+  repeated MachineMember machines = 1;
 }
 
-message ListMachineEndpointsRequest {
-  string id = 1;
+message Domain {
+  string name = 1;
 }
 
-message ListMachineEndpointsResponse {
-  MachineEndpoints endpoints = 1;
+message ReserveDomainRequest {
+  string endpoint = 1;
 }
 
-message MachineInfo {
-  string id = 1;
-  string name = 2;
-  NetworkConfig network = 3;
+message CreateDomainRecordsRequest {
+  repeated DNSRecord records = 1;
 }
 
-message NetworkConfig {
-  IPPrefix subnet = 1;
-  IP management_ip = 2;
-  repeated IPPort endpoints = 3;
-  bytes publicKey = 4;
+message CreateDomainRecordsResponse {
+  repeated DNSRecord records = 1;
 }
 
-message MachineEndpoints {
-  string id = 1;
-  repeated IPPort endpoints = 2;
-}
+message DNSRecord {
+  string name = 1;
 
-message User {
-  NetworkConfig network = 1;
+  enum RecordType {
+    UNSPECIFIED = 0;
+    A = 1;
+    AAAA = 2;
+  }
+  RecordType type = 2;
+  repeated string values = 3;
 }
-
-message State {
-  IPPrefix Network = 1;
-  // The machine configuration in the state is the source of truth set by the administrator.
-  // The machine itself can't update it.
-  map<string, MachineInfo> machines = 2;
-  map<string, MachineEndpoints> endpoints = 3;
-  repeated User users = 4;
-}
-

internal/machine/api/pb/cluster_grpc.pb.go

@@ -20,9 +20,12 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	Cluster_AddMachine_FullMethodName           = "/api.Cluster/AddMachine"
-	Cluster_ListMachines_FullMethodName         = "/api.Cluster/ListMachines"
-	Cluster_ListMachineEndpoints_FullMethodName = "/api.Cluster/ListMachineEndpoints"
+	Cluster_AddMachine_FullMethodName          = "/api.Cluster/AddMachine"
+	Cluster_ListMachines_FullMethodName        = "/api.Cluster/ListMachines"
+	Cluster_ReserveDomain_FullMethodName       = "/api.Cluster/ReserveDomain"
+	Cluster_GetDomain_FullMethodName           = "/api.Cluster/GetDomain"
+	Cluster_ReleaseDomain_FullMethodName       = "/api.Cluster/ReleaseDomain"
+	Cluster_CreateDomainRecords_FullMethodName = "/api.Cluster/CreateDomainRecords"
 )
 
 // ClusterClient is the client API for Cluster service.
@@ -31,7 +34,10 @@ const (
 type ClusterClient interface {
 	AddMachine(ctx context.Context, in *AddMachineRequest, opts ...grpc.CallOption) (*AddMachineResponse, error)
 	ListMachines(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListMachinesResponse, error)
-	ListMachineEndpoints(ctx context.Context, in *ListMachineEndpointsRequest, opts ...grpc.CallOption) (*ListMachineEndpointsResponse, error)
+	ReserveDomain(ctx context.Context, in *ReserveDomainRequest, opts ...grpc.CallOption) (*Domain, error)
+	GetDomain(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Domain, error)
+	ReleaseDomain(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Domain, error)
+	CreateDomainRecords(ctx context.Context, in *CreateDomainRecordsRequest, opts ...grpc.CallOption) (*CreateDomainRecordsResponse, error)
 }
 
 type clusterClient struct {
@@ -62,10 +68,40 @@ func (c *clusterClient) ListMachines(ctx context.Context, in *emptypb.Empty, opt
 	return out, nil
 }
 
-func (c *clusterClient) ListMachineEndpoints(ctx context.Context, in *ListMachineEndpointsRequest, opts ...grpc.CallOption) (*ListMachineEndpointsResponse, error) {
+func (c *clusterClient) ReserveDomain(ctx context.Context, in *ReserveDomainRequest, opts ...grpc.CallOption) (*Domain, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(ListMachineEndpointsResponse)
-	err := c.cc.Invoke(ctx, Cluster_ListMachineEndpoints_FullMethodName, in, out, cOpts...)
+	out := new(Domain)
+	err := c.cc.Invoke(ctx, Cluster_ReserveDomain_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) GetDomain(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Domain, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(Domain)
+	err := c.cc.Invoke(ctx, Cluster_GetDomain_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) ReleaseDomain(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Domain, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(Domain)
+	err := c.cc.Invoke(ctx, Cluster_ReleaseDomain_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) CreateDomainRecords(ctx context.Context, in *CreateDomainRecordsRequest, opts ...grpc.CallOption) (*CreateDomainRecordsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CreateDomainRecordsResponse)
+	err := c.cc.Invoke(ctx, Cluster_CreateDomainRecords_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -78,7 +114,10 @@ func (c *clusterClient) ListMachineEndpoints(ctx context.Context, in *ListMachin
 type ClusterServer interface {
 	AddMachine(context.Context, *AddMachineRequest) (*AddMachineResponse, error)
 	ListMachines(context.Context, *emptypb.Empty) (*ListMachinesResponse, error)
-	ListMachineEndpoints(context.Context, *ListMachineEndpointsRequest) (*ListMachineEndpointsResponse, error)
+	ReserveDomain(context.Context, *ReserveDomainRequest) (*Domain, error)
+	GetDomain(context.Context, *emptypb.Empty) (*Domain, error)
+	ReleaseDomain(context.Context, *emptypb.Empty) (*Domain, error)
+	CreateDomainRecords(context.Context, *CreateDomainRecordsRequest) (*CreateDomainRecordsResponse, error)
 	mustEmbedUnimplementedClusterServer()
 }
 
@@ -95,8 +134,17 @@ func (UnimplementedClusterServer) AddMachine(context.Context, *AddMachineRequest
 func (UnimplementedClusterServer) ListMachines(context.Context, *emptypb.Empty) (*ListMachinesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListMachines not implemented")
 }
-func (UnimplementedClusterServer) ListMachineEndpoints(context.Context, *ListMachineEndpointsRequest) (*ListMachineEndpointsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListMachineEndpoints not implemented")
+func (UnimplementedClusterServer) ReserveDomain(context.Context, *ReserveDomainRequest) (*Domain, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ReserveDomain not implemented")
+}
+func (UnimplementedClusterServer) GetDomain(context.Context, *emptypb.Empty) (*Domain, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetDomain not implemented")
+}
+func (UnimplementedClusterServer) ReleaseDomain(context.Context, *emptypb.Empty) (*Domain, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ReleaseDomain not implemented")
+}
+func (UnimplementedClusterServer) CreateDomainRecords(context.Context, *CreateDomainRecordsRequest) (*CreateDomainRecordsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateDomainRecords not implemented")
 }
 func (UnimplementedClusterServer) mustEmbedUnimplementedClusterServer() {}
 func (UnimplementedClusterServer) testEmbeddedByValue()                 {}
@@ -155,20 +203,74 @@ func _Cluster_ListMachines_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Cluster_ListMachineEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListMachineEndpointsRequest)
+func _Cluster_ReserveDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReserveDomainRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(ClusterServer).ListMachineEndpoints(ctx, in)
+		return srv.(ClusterServer).ReserveDomain(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: Cluster_ListMachineEndpoints_FullMethodName,
+		FullMethod: Cluster_ReserveDomain_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ClusterServer).ListMachineEndpoints(ctx, req.(*ListMachineEndpointsRequest))
+		return srv.(ClusterServer).ReserveDomain(ctx, req.(*ReserveDomainRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_GetDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(emptypb.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).GetDomain(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Cluster_GetDomain_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).GetDomain(ctx, req.(*emptypb.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_ReleaseDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(emptypb.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).ReleaseDomain(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Cluster_ReleaseDomain_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).ReleaseDomain(ctx, req.(*emptypb.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_CreateDomainRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateDomainRecordsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).CreateDomainRecords(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Cluster_CreateDomainRecords_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).CreateDomainRecords(ctx, req.(*CreateDomainRecordsRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -189,8 +291,20 @@ var Cluster_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _Cluster_ListMachines_Handler,
 		},
 		{
-			MethodName: "ListMachineEndpoints",
-			Handler:    _Cluster_ListMachineEndpoints_Handler,
+			MethodName: "ReserveDomain",
+			Handler:    _Cluster_ReserveDomain_Handler,
+		},
+		{
+			MethodName: "GetDomain",
+			Handler:    _Cluster_GetDomain_Handler,
+		},
+		{
+			MethodName: "ReleaseDomain",
+			Handler:    _Cluster_ReleaseDomain_Handler,
+		},
+		{
+			MethodName: "CreateDomainRecords",
+			Handler:    _Cluster_CreateDomainRecords_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},

internal/machine/api/pb/common.pb.go

@@ -7,6 +7,7 @@
 package pb
 
 import (
+	status "google.golang.org/genproto/googleapis/rpc/status"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
@@ -20,6 +21,171 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+// Common metadata message nested in all reply message types, injected by the gRPC proxy to provide information
+// about the machine that responded to the request.
+type Metadata struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Address of the machine the response came from.
+	Machine string `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
+	// error is set if the request to upstream failed. The rest of the response is undefined.
+	Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
+	// error as a gRPC Status message.
+	Status *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
+}
+
+func (x *Metadata) Reset() {
+	*x = Metadata{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Metadata) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Metadata) ProtoMessage() {}
+
+func (x *Metadata) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Metadata.ProtoReflect.Descriptor instead.
+func (*Metadata) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Metadata) GetMachine() string {
+	if x != nil {
+		return x.Machine
+	}
+	return ""
+}
+
+func (x *Metadata) GetError() string {
+	if x != nil {
+		return x.Error
+	}
+	return ""
+}
+
+func (x *Metadata) GetStatus() *status.Status {
+	if x != nil {
+		return x.Status
+	}
+	return nil
+}
+
+// A helper message for marshalling the metadata field and injecting it into the response by the gRPC proxy.
+type Empty struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
+}
+
+func (x *Empty) Reset() {
+	*x = Empty{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Empty) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Empty) ProtoMessage() {}
+
+func (x *Empty) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
+func (*Empty) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Empty) GetMetadata() *Metadata {
+	if x != nil {
+		return x.Metadata
+	}
+	return nil
+}
+
+// EmptyResponse is a response message to be returned by the gRPC proxy when a request to the upstream failed.
+// The nested Empty.Metadata message should contain an error.
+type EmptyResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Messages []*Empty `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
+}
+
+func (x *EmptyResponse) Reset() {
+	*x = EmptyResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *EmptyResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*EmptyResponse) ProtoMessage() {}
+
+func (x *EmptyResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use EmptyResponse.ProtoReflect.Descriptor instead.
+func (*EmptyResponse) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *EmptyResponse) GetMessages() []*Empty {
+	if x != nil {
+		return x.Messages
+	}
+	return nil
+}
+
 type IP struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -31,7 +197,7 @@ type IP struct {
 func (x *IP) Reset() {
 	*x = IP{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_common_proto_msgTypes[0]
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -44,7 +210,7 @@ func (x *IP) String() string {
 func (*IP) ProtoMessage() {}
 
 func (x *IP) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_common_proto_msgTypes[0]
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -57,7 +223,7 @@ func (x *IP) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use IP.ProtoReflect.Descriptor instead.
 func (*IP) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{0}
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{3}
 }
 
 func (x *IP) GetIp() []byte {
@@ -79,7 +245,7 @@ type IPPort struct {
 func (x *IPPort) Reset() {
 	*x = IPPort{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_common_proto_msgTypes[1]
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -92,7 +258,7 @@ func (x *IPPort) String() string {
 func (*IPPort) ProtoMessage() {}
 
 func (x *IPPort) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_common_proto_msgTypes[1]
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -105,7 +271,7 @@ func (x *IPPort) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use IPPort.ProtoReflect.Descriptor instead.
 func (*IPPort) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{1}
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *IPPort) GetIp() *IP {
@@ -134,7 +300,7 @@ type IPPrefix struct {
 func (x *IPPrefix) Reset() {
 	*x = IPPrefix{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_common_proto_msgTypes[2]
+		mi := &file_internal_machine_api_pb_common_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -147,7 +313,7 @@ func (x *IPPrefix) String() string {
 func (*IPPrefix) ProtoMessage() {}
 
 func (x *IPPrefix) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_common_proto_msgTypes[2]
+	mi := &file_internal_machine_api_pb_common_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -160,7 +326,7 @@ func (x *IPPrefix) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use IPPrefix.ProtoReflect.Descriptor instead.
 func (*IPPrefix) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{2}
+	return file_internal_machine_api_pb_common_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *IPPrefix) GetIp() *IP {
@@ -182,20 +348,34 @@ var File_internal_machine_api_pb_common_proto protoreflect.FileDescriptor
 var file_internal_machine_api_pb_common_proto_rawDesc = []byte{
 	0x0a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69,
 	0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x61, 0x70, 0x69, 0x22, 0x14, 0x0a, 0x02, 0x49,
-	0x50, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69,
-	0x70, 0x22, 0x35, 0x0a, 0x06, 0x49, 0x50, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x17, 0x0a, 0x02, 0x69,
-	0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50,
-	0x52, 0x02, 0x69, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0d, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x37, 0x0a, 0x08, 0x49, 0x50, 0x50, 0x72,
-	0x65, 0x66, 0x69, 0x78, 0x12, 0x17, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x07, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x52, 0x02, 0x69, 0x70, 0x12, 0x12, 0x0a,
-	0x04, 0x62, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x62, 0x69, 0x74,
-	0x73, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x70, 0x73, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x6b, 0x69, 0x2f, 0x75, 0x6e, 0x63, 0x6c, 0x6f,
-	0x75, 0x64, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x33,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x61, 0x70, 0x69, 0x1a, 0x17, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x22, 0x66, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x12, 0x18, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72,
+	0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72,
+	0x12, 0x2a, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x12, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74,
+	0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x32, 0x0a, 0x05,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x29, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+	0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x22, 0x37, 0x0a, 0x0d, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x26, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x52,
+	0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x22, 0x14, 0x0a, 0x02, 0x49, 0x50, 0x12,
+	0x0e, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x70, 0x22,
+	0x35, 0x0a, 0x06, 0x49, 0x50, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x17, 0x0a, 0x02, 0x69, 0x70, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x52, 0x02,
+	0x69, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x37, 0x0a, 0x08, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66,
+	0x69, 0x78, 0x12, 0x17, 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x07,
+	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x52, 0x02, 0x69, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x62,
+	0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x62, 0x69, 0x74, 0x73, 0x42,
+	0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x73,
+	0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x6b, 0x69, 0x2f, 0x75, 0x6e, 0x63, 0x6c, 0x6f, 0x75, 0x64,
+	0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
+	0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -210,20 +390,27 @@ func file_internal_machine_api_pb_common_proto_rawDescGZIP() []byte {
 	return file_internal_machine_api_pb_common_proto_rawDescData
 }
 
-var file_internal_machine_api_pb_common_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_internal_machine_api_pb_common_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
 var file_internal_machine_api_pb_common_proto_goTypes = []any{
-	(*IP)(nil),       // 0: api.IP
-	(*IPPort)(nil),   // 1: api.IPPort
-	(*IPPrefix)(nil), // 2: api.IPPrefix
+	(*Metadata)(nil),      // 0: api.Metadata
+	(*Empty)(nil),         // 1: api.Empty
+	(*EmptyResponse)(nil), // 2: api.EmptyResponse
+	(*IP)(nil),            // 3: api.IP
+	(*IPPort)(nil),        // 4: api.IPPort
+	(*IPPrefix)(nil),      // 5: api.IPPrefix
+	(*status.Status)(nil), // 6: google.rpc.Status
 }
 var file_internal_machine_api_pb_common_proto_depIdxs = []int32{
-	0, // 0: api.IPPort.ip:type_name -> api.IP
-	0, // 1: api.IPPrefix.ip:type_name -> api.IP
-	2, // [2:2] is the sub-list for method output_type
-	2, // [2:2] is the sub-list for method input_type
-	2, // [2:2] is the sub-list for extension type_name
-	2, // [2:2] is the sub-list for extension extendee
-	0, // [0:2] is the sub-list for field type_name
+	6, // 0: api.Metadata.status:type_name -> google.rpc.Status
+	0, // 1: api.Empty.metadata:type_name -> api.Metadata
+	1, // 2: api.EmptyResponse.messages:type_name -> api.Empty
+	3, // 3: api.IPPort.ip:type_name -> api.IP
+	3, // 4: api.IPPrefix.ip:type_name -> api.IP
+	5, // [5:5] is the sub-list for method output_type
+	5, // [5:5] is the sub-list for method input_type
+	5, // [5:5] is the sub-list for extension type_name
+	5, // [5:5] is the sub-list for extension extendee
+	0, // [0:5] is the sub-list for field type_name
 }
 
 func init() { file_internal_machine_api_pb_common_proto_init() }
@@ -233,7 +420,7 @@ func file_internal_machine_api_pb_common_proto_init() {
 	}
 	if !protoimpl.UnsafeEnabled {
 		file_internal_machine_api_pb_common_proto_msgTypes[0].Exporter = func(v any, i int) any {
-			switch v := v.(*IP); i {
+			switch v := v.(*Metadata); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -245,7 +432,7 @@ func file_internal_machine_api_pb_common_proto_init() {
 			}
 		}
 		file_internal_machine_api_pb_common_proto_msgTypes[1].Exporter = func(v any, i int) any {
-			switch v := v.(*IPPort); i {
+			switch v := v.(*Empty); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -257,6 +444,42 @@ func file_internal_machine_api_pb_common_proto_init() {
 			}
 		}
 		file_internal_machine_api_pb_common_proto_msgTypes[2].Exporter = func(v any, i int) any {
+			switch v := v.(*EmptyResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_common_proto_msgTypes[3].Exporter = func(v any, i int) any {
+			switch v := v.(*IP); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_common_proto_msgTypes[4].Exporter = func(v any, i int) any {
+			switch v := v.(*IPPort); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_common_proto_msgTypes[5].Exporter = func(v any, i int) any {
 			switch v := v.(*IPPrefix); i {
 			case 0:
 				return &v.state
@@ -275,7 +498,7 @@ func file_internal_machine_api_pb_common_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_internal_machine_api_pb_common_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   3,
+			NumMessages:   6,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

internal/machine/api/pb/common.proto

@@ -4,6 +4,31 @@ package api;
 
 option go_package = "github.com/psviderski/uncloud/internal/machine/api/pb";
 
+// Vendored at internal/machine/api/vendor/google/rpc/status.proto.
+import "google/rpc/status.proto";
+
+// Common metadata message nested in all reply message types, injected by the gRPC proxy to provide information
+// about the machine that responded to the request.
+message Metadata {
+  // Address of the machine the response came from.
+  string machine = 1;
+  // error is set if the request to upstream failed. The rest of the response is undefined.
+  string error = 2;
+  // error as a gRPC Status message.
+  google.rpc.Status status = 3;
+}
+
+// A helper message for marshalling the metadata field and injecting it into the response by the gRPC proxy.
+message Empty {
+  Metadata metadata = 1;
+}
+
+// EmptyResponse is a response message to be returned by the gRPC proxy when a request to the upstream failed.
+// The nested Empty.Metadata message should contain an error.
+message EmptyResponse {
+  repeated Empty messages = 1;
+}
+
 message IP {
   bytes ip = 1;
 }

internal/machine/api/pb/docker.pb.go

@@ -0,0 +1,999 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.34.2
+// 	protoc        v5.27.3
+// source: internal/machine/api/pb/docker.proto
+
+package pb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type CreateContainerRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// JSON serialized container.Config.
+	Config []byte `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
+	// JSON serialized container.HostConfig.
+	HostConfig []byte `protobuf:"bytes,2,opt,name=host_config,json=hostConfig,proto3" json:"host_config,omitempty"`
+	// JSON serialized network.NetworkingConfig.
+	NetworkConfig []byte `protobuf:"bytes,3,opt,name=network_config,json=networkConfig,proto3" json:"network_config,omitempty"`
+	// JSON serialized ocispec.Platform.
+	Platform []byte `protobuf:"bytes,4,opt,name=platform,proto3" json:"platform,omitempty"`
+	Name     string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (x *CreateContainerRequest) Reset() {
+	*x = CreateContainerRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CreateContainerRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateContainerRequest) ProtoMessage() {}
+
+func (x *CreateContainerRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateContainerRequest.ProtoReflect.Descriptor instead.
+func (*CreateContainerRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *CreateContainerRequest) GetConfig() []byte {
+	if x != nil {
+		return x.Config
+	}
+	return nil
+}
+
+func (x *CreateContainerRequest) GetHostConfig() []byte {
+	if x != nil {
+		return x.HostConfig
+	}
+	return nil
+}
+
+func (x *CreateContainerRequest) GetNetworkConfig() []byte {
+	if x != nil {
+		return x.NetworkConfig
+	}
+	return nil
+}
+
+func (x *CreateContainerRequest) GetPlatform() []byte {
+	if x != nil {
+		return x.Platform
+	}
+	return nil
+}
+
+func (x *CreateContainerRequest) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+type CreateContainerResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// JSON serialized container.CreateResponse.
+	Response []byte `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
+}
+
+func (x *CreateContainerResponse) Reset() {
+	*x = CreateContainerResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CreateContainerResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CreateContainerResponse) ProtoMessage() {}
+
+func (x *CreateContainerResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use CreateContainerResponse.ProtoReflect.Descriptor instead.
+func (*CreateContainerResponse) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *CreateContainerResponse) GetResponse() []byte {
+	if x != nil {
+		return x.Response
+	}
+	return nil
+}
+
+type InspectContainerRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *InspectContainerRequest) Reset() {
+	*x = InspectContainerRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *InspectContainerRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InspectContainerRequest) ProtoMessage() {}
+
+func (x *InspectContainerRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use InspectContainerRequest.ProtoReflect.Descriptor instead.
+func (*InspectContainerRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *InspectContainerRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+type InspectContainerResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// JSON serialized container.InspectResponse.
+	Response []byte `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
+}
+
+func (x *InspectContainerResponse) Reset() {
+	*x = InspectContainerResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *InspectContainerResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InspectContainerResponse) ProtoMessage() {}
+
+func (x *InspectContainerResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use InspectContainerResponse.ProtoReflect.Descriptor instead.
+func (*InspectContainerResponse) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *InspectContainerResponse) GetResponse() []byte {
+	if x != nil {
+		return x.Response
+	}
+	return nil
+}
+
+type StartContainerRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	// JSON serialized container.StartOptions.
+	Options []byte `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
+}
+
+func (x *StartContainerRequest) Reset() {
+	*x = StartContainerRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StartContainerRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StartContainerRequest) ProtoMessage() {}
+
+func (x *StartContainerRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StartContainerRequest.ProtoReflect.Descriptor instead.
+func (*StartContainerRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *StartContainerRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *StartContainerRequest) GetOptions() []byte {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+type StopContainerRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	// JSON serialized container.StopOptions.
+	Options []byte `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
+}
+
+func (x *StopContainerRequest) Reset() {
+	*x = StopContainerRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StopContainerRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StopContainerRequest) ProtoMessage() {}
+
+func (x *StopContainerRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StopContainerRequest.ProtoReflect.Descriptor instead.
+func (*StopContainerRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *StopContainerRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *StopContainerRequest) GetOptions() []byte {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+type ListContainersRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// JSON serialized container.ListOptions.
+	Options []byte `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
+}
+
+func (x *ListContainersRequest) Reset() {
+	*x = ListContainersRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ListContainersRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListContainersRequest) ProtoMessage() {}
+
+func (x *ListContainersRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListContainersRequest.ProtoReflect.Descriptor instead.
+func (*ListContainersRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *ListContainersRequest) GetOptions() []byte {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+// ListContainersResponse structure allows broadcasting ListContainers requests to multiple machines.
+type ListContainersResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Messages []*MachineContainers `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
+}
+
+func (x *ListContainersResponse) Reset() {
+	*x = ListContainersResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ListContainersResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ListContainersResponse) ProtoMessage() {}
+
+func (x *ListContainersResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ListContainersResponse.ProtoReflect.Descriptor instead.
+func (*ListContainersResponse) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *ListContainersResponse) GetMessages() []*MachineContainers {
+	if x != nil {
+		return x.Messages
+	}
+	return nil
+}
+
+type MachineContainers struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
+	// JSON serialized []container.ContainerJSON.
+	Containers []byte `protobuf:"bytes,2,opt,name=containers,proto3" json:"containers,omitempty"`
+}
+
+func (x *MachineContainers) Reset() {
+	*x = MachineContainers{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MachineContainers) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MachineContainers) ProtoMessage() {}
+
+func (x *MachineContainers) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MachineContainers.ProtoReflect.Descriptor instead.
+func (*MachineContainers) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *MachineContainers) GetMetadata() *Metadata {
+	if x != nil {
+		return x.Metadata
+	}
+	return nil
+}
+
+func (x *MachineContainers) GetContainers() []byte {
+	if x != nil {
+		return x.Containers
+	}
+	return nil
+}
+
+type RemoveContainerRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	// JSON serialized container.RemoveOptions.
+	Options []byte `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
+}
+
+func (x *RemoveContainerRequest) Reset() {
+	*x = RemoveContainerRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RemoveContainerRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RemoveContainerRequest) ProtoMessage() {}
+
+func (x *RemoveContainerRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RemoveContainerRequest.ProtoReflect.Descriptor instead.
+func (*RemoveContainerRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *RemoveContainerRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *RemoveContainerRequest) GetOptions() []byte {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+type PullImageRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
+	// JSON serialized image.PullOptions.
+	Options []byte `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
+}
+
+func (x *PullImageRequest) Reset() {
+	*x = PullImageRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *PullImageRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PullImageRequest) ProtoMessage() {}
+
+func (x *PullImageRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[10]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PullImageRequest.ProtoReflect.Descriptor instead.
+func (*PullImageRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *PullImageRequest) GetImage() string {
+	if x != nil {
+		return x.Image
+	}
+	return ""
+}
+
+func (x *PullImageRequest) GetOptions() []byte {
+	if x != nil {
+		return x.Options
+	}
+	return nil
+}
+
+type JSONMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// JSON serialized jsonmessage.JSONMessage.
+	Message []byte `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+}
+
+func (x *JSONMessage) Reset() {
+	*x = JSONMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_docker_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *JSONMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*JSONMessage) ProtoMessage() {}
+
+func (x *JSONMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_docker_proto_msgTypes[11]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use JSONMessage.ProtoReflect.Descriptor instead.
+func (*JSONMessage) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_docker_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *JSONMessage) GetMessage() []byte {
+	if x != nil {
+		return x.Message
+	}
+	return nil
+}
+
+var File_internal_machine_api_pb_docker_proto protoreflect.FileDescriptor
+
+var file_internal_machine_api_pb_docker_proto_rawDesc = []byte{
+	0x0a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69,
+	0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x2f, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x61, 0x70, 0x69, 0x1a, 0x1b, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70,
+	0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
+	0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70,
+	0x62, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa8,
+	0x01, 0x0a, 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
+	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6e,
+	0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69,
+	0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x68, 0x6f, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x63, 0x6f,
+	0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6e, 0x65, 0x74, 0x77,
+	0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6c, 0x61,
+	0x74, 0x66, 0x6f, 0x72, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x6c, 0x61,
+	0x74, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x35, 0x0a, 0x17, 0x43, 0x72, 0x65,
+	0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x29, 0x0a, 0x17, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61,
+	0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x36, 0x0a, 0x18, 0x49,
+	0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x41, 0x0a, 0x15, 0x53, 0x74, 0x61, 0x72, 0x74, 0x43, 0x6f, 0x6e, 0x74,
+	0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07,
+	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6f,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x40, 0x0a, 0x14, 0x53, 0x74, 0x6f, 0x70, 0x43, 0x6f,
+	0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e,
+	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18,
+	0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x31, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74,
+	0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, 0x0a, 0x16, 0x4c,
+	0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61,
+	0x63, 0x68, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x52,
+	0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x22, 0x5e, 0x0a, 0x11, 0x4d, 0x61, 0x63,
+	0x68, 0x69, 0x6e, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x29,
+	0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52,
+	0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6e,
+	0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63,
+	0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x42, 0x0a, 0x16, 0x52, 0x65, 0x6d,
+	0x6f, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x42, 0x0a,
+	0x10, 0x50, 0x75, 0x6c, 0x6c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x22, 0x27, 0x0a, 0x0b, 0x4a, 0x53, 0x4f, 0x4e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0xfc, 0x03, 0x0a, 0x06, 0x44,
+	0x6f, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x4c, 0x0a, 0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43,
+	0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x1b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43,
+	0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x43, 0x72, 0x65, 0x61,
+	0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x10, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x43, 0x6f,
+	0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e,
+	0x73, 0x70, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e, 0x73, 0x70,
+	0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x43, 0x6f, 0x6e,
+	0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x53, 0x74, 0x61,
+	0x72, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x42, 0x0a, 0x0d, 0x53, 0x74,
+	0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x61, 0x70,
+	0x69, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x49,
+	0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73,
+	0x12, 0x1a, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61,
+	0x69, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61,
+	0x70, 0x69, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0f, 0x52, 0x65, 0x6d,
+	0x6f, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x1b, 0x2e, 0x61,
+	0x70, 0x69, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
+	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x12, 0x36, 0x0a, 0x09, 0x50, 0x75, 0x6c, 0x6c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x15,
+	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x50, 0x75, 0x6c, 0x6c, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4a, 0x53, 0x4f, 0x4e,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x01, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74,
+	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x73, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73,
+	0x6b, 0x69, 0x2f, 0x75, 0x6e, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72,
+	0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f,
+	0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_internal_machine_api_pb_docker_proto_rawDescOnce sync.Once
+	file_internal_machine_api_pb_docker_proto_rawDescData = file_internal_machine_api_pb_docker_proto_rawDesc
+)
+
+func file_internal_machine_api_pb_docker_proto_rawDescGZIP() []byte {
+	file_internal_machine_api_pb_docker_proto_rawDescOnce.Do(func() {
+		file_internal_machine_api_pb_docker_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_machine_api_pb_docker_proto_rawDescData)
+	})
+	return file_internal_machine_api_pb_docker_proto_rawDescData
+}
+
+var file_internal_machine_api_pb_docker_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
+var file_internal_machine_api_pb_docker_proto_goTypes = []any{
+	(*CreateContainerRequest)(nil),   // 0: api.CreateContainerRequest
+	(*CreateContainerResponse)(nil),  // 1: api.CreateContainerResponse
+	(*InspectContainerRequest)(nil),  // 2: api.InspectContainerRequest
+	(*InspectContainerResponse)(nil), // 3: api.InspectContainerResponse
+	(*StartContainerRequest)(nil),    // 4: api.StartContainerRequest
+	(*StopContainerRequest)(nil),     // 5: api.StopContainerRequest
+	(*ListContainersRequest)(nil),    // 6: api.ListContainersRequest
+	(*ListContainersResponse)(nil),   // 7: api.ListContainersResponse
+	(*MachineContainers)(nil),        // 8: api.MachineContainers
+	(*RemoveContainerRequest)(nil),   // 9: api.RemoveContainerRequest
+	(*PullImageRequest)(nil),         // 10: api.PullImageRequest
+	(*JSONMessage)(nil),              // 11: api.JSONMessage
+	(*Metadata)(nil),                 // 12: api.Metadata
+	(*emptypb.Empty)(nil),            // 13: google.protobuf.Empty
+}
+var file_internal_machine_api_pb_docker_proto_depIdxs = []int32{
+	8,  // 0: api.ListContainersResponse.messages:type_name -> api.MachineContainers
+	12, // 1: api.MachineContainers.metadata:type_name -> api.Metadata
+	0,  // 2: api.Docker.CreateContainer:input_type -> api.CreateContainerRequest
+	2,  // 3: api.Docker.InspectContainer:input_type -> api.InspectContainerRequest
+	4,  // 4: api.Docker.StartContainer:input_type -> api.StartContainerRequest
+	5,  // 5: api.Docker.StopContainer:input_type -> api.StopContainerRequest
+	6,  // 6: api.Docker.ListContainers:input_type -> api.ListContainersRequest
+	9,  // 7: api.Docker.RemoveContainer:input_type -> api.RemoveContainerRequest
+	10, // 8: api.Docker.PullImage:input_type -> api.PullImageRequest
+	1,  // 9: api.Docker.CreateContainer:output_type -> api.CreateContainerResponse
+	3,  // 10: api.Docker.InspectContainer:output_type -> api.InspectContainerResponse
+	13, // 11: api.Docker.StartContainer:output_type -> google.protobuf.Empty
+	13, // 12: api.Docker.StopContainer:output_type -> google.protobuf.Empty
+	7,  // 13: api.Docker.ListContainers:output_type -> api.ListContainersResponse
+	13, // 14: api.Docker.RemoveContainer:output_type -> google.protobuf.Empty
+	11, // 15: api.Docker.PullImage:output_type -> api.JSONMessage
+	9,  // [9:16] is the sub-list for method output_type
+	2,  // [2:9] is the sub-list for method input_type
+	2,  // [2:2] is the sub-list for extension type_name
+	2,  // [2:2] is the sub-list for extension extendee
+	0,  // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_internal_machine_api_pb_docker_proto_init() }
+func file_internal_machine_api_pb_docker_proto_init() {
+	if File_internal_machine_api_pb_docker_proto != nil {
+		return
+	}
+	file_internal_machine_api_pb_common_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_internal_machine_api_pb_docker_proto_msgTypes[0].Exporter = func(v any, i int) any {
+			switch v := v.(*CreateContainerRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[1].Exporter = func(v any, i int) any {
+			switch v := v.(*CreateContainerResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[2].Exporter = func(v any, i int) any {
+			switch v := v.(*InspectContainerRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[3].Exporter = func(v any, i int) any {
+			switch v := v.(*InspectContainerResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[4].Exporter = func(v any, i int) any {
+			switch v := v.(*StartContainerRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[5].Exporter = func(v any, i int) any {
+			switch v := v.(*StopContainerRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[6].Exporter = func(v any, i int) any {
+			switch v := v.(*ListContainersRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[7].Exporter = func(v any, i int) any {
+			switch v := v.(*ListContainersResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[8].Exporter = func(v any, i int) any {
+			switch v := v.(*MachineContainers); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[9].Exporter = func(v any, i int) any {
+			switch v := v.(*RemoveContainerRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[10].Exporter = func(v any, i int) any {
+			switch v := v.(*PullImageRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_docker_proto_msgTypes[11].Exporter = func(v any, i int) any {
+			switch v := v.(*JSONMessage); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_internal_machine_api_pb_docker_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   12,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_internal_machine_api_pb_docker_proto_goTypes,
+		DependencyIndexes: file_internal_machine_api_pb_docker_proto_depIdxs,
+		MessageInfos:      file_internal_machine_api_pb_docker_proto_msgTypes,
+	}.Build()
+	File_internal_machine_api_pb_docker_proto = out.File
+	file_internal_machine_api_pb_docker_proto_rawDesc = nil
+	file_internal_machine_api_pb_docker_proto_goTypes = nil
+	file_internal_machine_api_pb_docker_proto_depIdxs = nil
+}

internal/machine/api/pb/docker.proto

@@ -0,0 +1,89 @@
+syntax = "proto3";
+
+package api;
+
+option go_package = "github.com/psviderski/uncloud/internal/machine/api/pb";
+
+import "google/protobuf/empty.proto";
+import "internal/machine/api/pb/common.proto";
+
+service Docker {
+  rpc CreateContainer(CreateContainerRequest) returns (CreateContainerResponse);
+  rpc InspectContainer(InspectContainerRequest) returns (InspectContainerResponse);
+  rpc StartContainer(StartContainerRequest) returns (google.protobuf.Empty);
+  rpc StopContainer(StopContainerRequest) returns (google.protobuf.Empty);
+  rpc ListContainers(ListContainersRequest) returns (ListContainersResponse);
+  rpc RemoveContainer(RemoveContainerRequest) returns (google.protobuf.Empty);
+  rpc PullImage(PullImageRequest) returns (stream JSONMessage);
+}
+
+message CreateContainerRequest {
+  // JSON serialized container.Config.
+  bytes config = 1;
+  // JSON serialized container.HostConfig.
+  bytes host_config = 2;
+  // JSON serialized network.NetworkingConfig.
+  bytes network_config = 3;
+  // JSON serialized ocispec.Platform.
+  bytes platform = 4;
+  string name = 5;
+}
+
+message CreateContainerResponse {
+  // JSON serialized container.CreateResponse.
+  bytes response = 1;
+}
+
+message InspectContainerRequest {
+  string id = 1;
+}
+
+message InspectContainerResponse {
+  // JSON serialized container.InspectResponse.
+  bytes response = 1;
+}
+
+message StartContainerRequest {
+  string id = 1;
+  // JSON serialized container.StartOptions.
+  bytes options = 2;
+}
+
+message StopContainerRequest {
+  string id = 1;
+  // JSON serialized container.StopOptions.
+  bytes options = 2;
+}
+
+message ListContainersRequest {
+  // JSON serialized container.ListOptions.
+  bytes options = 1;
+}
+
+// ListContainersResponse structure allows broadcasting ListContainers requests to multiple machines.
+message ListContainersResponse {
+  repeated MachineContainers messages = 1;
+}
+
+message MachineContainers {
+  Metadata metadata = 1;
+  // JSON serialized []container.ContainerJSON.
+  bytes containers = 2;
+}
+
+message RemoveContainerRequest {
+  string id = 1;
+  // JSON serialized container.RemoveOptions.
+  bytes options = 2;
+}
+
+message PullImageRequest {
+  string image = 1;
+  // JSON serialized image.PullOptions.
+  bytes options = 2;
+}
+
+message JSONMessage {
+  // JSON serialized jsonmessage.JSONMessage.
+  bytes message = 1;
+}

internal/machine/api/pb/docker_grpc.pb.go

@@ -0,0 +1,354 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v5.27.3
+// source: internal/machine/api/pb/docker.proto
+
+package pb
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Docker_CreateContainer_FullMethodName  = "/api.Docker/CreateContainer"
+	Docker_InspectContainer_FullMethodName = "/api.Docker/InspectContainer"
+	Docker_StartContainer_FullMethodName   = "/api.Docker/StartContainer"
+	Docker_StopContainer_FullMethodName    = "/api.Docker/StopContainer"
+	Docker_ListContainers_FullMethodName   = "/api.Docker/ListContainers"
+	Docker_RemoveContainer_FullMethodName  = "/api.Docker/RemoveContainer"
+	Docker_PullImage_FullMethodName        = "/api.Docker/PullImage"
+)
+
+// DockerClient is the client API for Docker service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type DockerClient interface {
+	CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error)
+	InspectContainer(ctx context.Context, in *InspectContainerRequest, opts ...grpc.CallOption) (*InspectContainerResponse, error)
+	StartContainer(ctx context.Context, in *StartContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	StopContainer(ctx context.Context, in *StopContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	ListContainers(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error)
+	RemoveContainer(ctx context.Context, in *RemoveContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+	PullImage(ctx context.Context, in *PullImageRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[JSONMessage], error)
+}
+
+type dockerClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewDockerClient(cc grpc.ClientConnInterface) DockerClient {
+	return &dockerClient{cc}
+}
+
+func (c *dockerClient) CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(CreateContainerResponse)
+	err := c.cc.Invoke(ctx, Docker_CreateContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) InspectContainer(ctx context.Context, in *InspectContainerRequest, opts ...grpc.CallOption) (*InspectContainerResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(InspectContainerResponse)
+	err := c.cc.Invoke(ctx, Docker_InspectContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) StartContainer(ctx context.Context, in *StartContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Docker_StartContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) StopContainer(ctx context.Context, in *StopContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Docker_StopContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) ListContainers(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ListContainersResponse)
+	err := c.cc.Invoke(ctx, Docker_ListContainers_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) RemoveContainer(ctx context.Context, in *RemoveContainerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Docker_RemoveContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *dockerClient) PullImage(ctx context.Context, in *PullImageRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[JSONMessage], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &Docker_ServiceDesc.Streams[0], Docker_PullImage_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[PullImageRequest, JSONMessage]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Docker_PullImageClient = grpc.ServerStreamingClient[JSONMessage]
+
+// DockerServer is the server API for Docker service.
+// All implementations must embed UnimplementedDockerServer
+// for forward compatibility.
+type DockerServer interface {
+	CreateContainer(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error)
+	InspectContainer(context.Context, *InspectContainerRequest) (*InspectContainerResponse, error)
+	StartContainer(context.Context, *StartContainerRequest) (*emptypb.Empty, error)
+	StopContainer(context.Context, *StopContainerRequest) (*emptypb.Empty, error)
+	ListContainers(context.Context, *ListContainersRequest) (*ListContainersResponse, error)
+	RemoveContainer(context.Context, *RemoveContainerRequest) (*emptypb.Empty, error)
+	PullImage(*PullImageRequest, grpc.ServerStreamingServer[JSONMessage]) error
+	mustEmbedUnimplementedDockerServer()
+}
+
+// UnimplementedDockerServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedDockerServer struct{}
+
+func (UnimplementedDockerServer) CreateContainer(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateContainer not implemented")
+}
+func (UnimplementedDockerServer) InspectContainer(context.Context, *InspectContainerRequest) (*InspectContainerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method InspectContainer not implemented")
+}
+func (UnimplementedDockerServer) StartContainer(context.Context, *StartContainerRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method StartContainer not implemented")
+}
+func (UnimplementedDockerServer) StopContainer(context.Context, *StopContainerRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method StopContainer not implemented")
+}
+func (UnimplementedDockerServer) ListContainers(context.Context, *ListContainersRequest) (*ListContainersResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListContainers not implemented")
+}
+func (UnimplementedDockerServer) RemoveContainer(context.Context, *RemoveContainerRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RemoveContainer not implemented")
+}
+func (UnimplementedDockerServer) PullImage(*PullImageRequest, grpc.ServerStreamingServer[JSONMessage]) error {
+	return status.Errorf(codes.Unimplemented, "method PullImage not implemented")
+}
+func (UnimplementedDockerServer) mustEmbedUnimplementedDockerServer() {}
+func (UnimplementedDockerServer) testEmbeddedByValue()                {}
+
+// UnsafeDockerServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to DockerServer will
+// result in compilation errors.
+type UnsafeDockerServer interface {
+	mustEmbedUnimplementedDockerServer()
+}
+
+func RegisterDockerServer(s grpc.ServiceRegistrar, srv DockerServer) {
+	// If the following call pancis, it indicates UnimplementedDockerServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Docker_ServiceDesc, srv)
+}
+
+func _Docker_CreateContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).CreateContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_CreateContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).CreateContainer(ctx, req.(*CreateContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_InspectContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(InspectContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).InspectContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_InspectContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).InspectContainer(ctx, req.(*InspectContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_StartContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StartContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).StartContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_StartContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).StartContainer(ctx, req.(*StartContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_StopContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StopContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).StopContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_StopContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).StopContainer(ctx, req.(*StopContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_ListContainers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListContainersRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).ListContainers(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_ListContainers_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).ListContainers(ctx, req.(*ListContainersRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_RemoveContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RemoveContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DockerServer).RemoveContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Docker_RemoveContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DockerServer).RemoveContainer(ctx, req.(*RemoveContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Docker_PullImage_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(PullImageRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DockerServer).PullImage(m, &grpc.GenericServerStream[PullImageRequest, JSONMessage]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Docker_PullImageServer = grpc.ServerStreamingServer[JSONMessage]
+
+// Docker_ServiceDesc is the grpc.ServiceDesc for Docker service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Docker_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "api.Docker",
+	HandlerType: (*DockerServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateContainer",
+			Handler:    _Docker_CreateContainer_Handler,
+		},
+		{
+			MethodName: "InspectContainer",
+			Handler:    _Docker_InspectContainer_Handler,
+		},
+		{
+			MethodName: "StartContainer",
+			Handler:    _Docker_StartContainer_Handler,
+		},
+		{
+			MethodName: "StopContainer",
+			Handler:    _Docker_StopContainer_Handler,
+		},
+		{
+			MethodName: "ListContainers",
+			Handler:    _Docker_ListContainers_Handler,
+		},
+		{
+			MethodName: "RemoveContainer",
+			Handler:    _Docker_RemoveContainer_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "PullImage",
+			Handler:       _Docker_PullImage_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "internal/machine/api/pb/docker.proto",
+}

internal/machine/api/pb/machine.pb.go

@@ -21,6 +21,148 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+type MachineInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id       string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Name     string         `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Network  *NetworkConfig `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"`
+	PublicIp *IP            `protobuf:"bytes,4,opt,name=public_ip,json=publicIp,proto3" json:"public_ip,omitempty"`
+}
+
+func (x *MachineInfo) Reset() {
+	*x = MachineInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MachineInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MachineInfo) ProtoMessage() {}
+
+func (x *MachineInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MachineInfo.ProtoReflect.Descriptor instead.
+func (*MachineInfo) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MachineInfo) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *MachineInfo) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *MachineInfo) GetNetwork() *NetworkConfig {
+	if x != nil {
+		return x.Network
+	}
+	return nil
+}
+
+func (x *MachineInfo) GetPublicIp() *IP {
+	if x != nil {
+		return x.PublicIp
+	}
+	return nil
+}
+
+type NetworkConfig struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Subnet       *IPPrefix `protobuf:"bytes,1,opt,name=subnet,proto3" json:"subnet,omitempty"`
+	ManagementIp *IP       `protobuf:"bytes,2,opt,name=management_ip,json=managementIp,proto3" json:"management_ip,omitempty"`
+	Endpoints    []*IPPort `protobuf:"bytes,3,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
+	PublicKey    []byte    `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
+}
+
+func (x *NetworkConfig) Reset() {
+	*x = NetworkConfig{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NetworkConfig) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NetworkConfig) ProtoMessage() {}
+
+func (x *NetworkConfig) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NetworkConfig.ProtoReflect.Descriptor instead.
+func (*NetworkConfig) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *NetworkConfig) GetSubnet() *IPPrefix {
+	if x != nil {
+		return x.Subnet
+	}
+	return nil
+}
+
+func (x *NetworkConfig) GetManagementIp() *IP {
+	if x != nil {
+		return x.ManagementIp
+	}
+	return nil
+}
+
+func (x *NetworkConfig) GetEndpoints() []*IPPort {
+	if x != nil {
+		return x.Endpoints
+	}
+	return nil
+}
+
+func (x *NetworkConfig) GetPublicKey() []byte {
+	if x != nil {
+		return x.PublicKey
+	}
+	return nil
+}
+
 type InitClusterRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -28,13 +170,17 @@ type InitClusterRequest struct {
 
 	MachineName string    `protobuf:"bytes,1,opt,name=machineName,proto3" json:"machineName,omitempty"`
 	Network     *IPPrefix `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
-	User        *User     `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
+	// Types that are assignable to PublicIpConfig:
+	//
+	//	*InitClusterRequest_PublicIp
+	//	*InitClusterRequest_PublicIpAuto
+	PublicIpConfig isInitClusterRequest_PublicIpConfig `protobuf_oneof:"public_ip_config"`
 }
 
 func (x *InitClusterRequest) Reset() {
 	*x = InitClusterRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[0]
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -47,7 +193,7 @@ func (x *InitClusterRequest) String() string {
 func (*InitClusterRequest) ProtoMessage() {}
 
 func (x *InitClusterRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[0]
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -60,7 +206,7 @@ func (x *InitClusterRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use InitClusterRequest.ProtoReflect.Descriptor instead.
 func (*InitClusterRequest) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{0}
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *InitClusterRequest) GetMachineName() string {
@@ -77,13 +223,43 @@ func (x *InitClusterRequest) GetNetwork() *IPPrefix {
 	return nil
 }
 
-func (x *InitClusterRequest) GetUser() *User {
-	if x != nil {
-		return x.User
+func (m *InitClusterRequest) GetPublicIpConfig() isInitClusterRequest_PublicIpConfig {
+	if m != nil {
+		return m.PublicIpConfig
 	}
 	return nil
 }
 
+func (x *InitClusterRequest) GetPublicIp() *IP {
+	if x, ok := x.GetPublicIpConfig().(*InitClusterRequest_PublicIp); ok {
+		return x.PublicIp
+	}
+	return nil
+}
+
+func (x *InitClusterRequest) GetPublicIpAuto() bool {
+	if x, ok := x.GetPublicIpConfig().(*InitClusterRequest_PublicIpAuto); ok {
+		return x.PublicIpAuto
+	}
+	return false
+}
+
+type isInitClusterRequest_PublicIpConfig interface {
+	isInitClusterRequest_PublicIpConfig()
+}
+
+type InitClusterRequest_PublicIp struct {
+	PublicIp *IP `protobuf:"bytes,3,opt,name=public_ip,json=publicIp,proto3,oneof"`
+}
+
+type InitClusterRequest_PublicIpAuto struct {
+	PublicIpAuto bool `protobuf:"varint,4,opt,name=public_ip_auto,json=publicIpAuto,proto3,oneof"`
+}
+
+func (*InitClusterRequest_PublicIp) isInitClusterRequest_PublicIpConfig() {}
+
+func (*InitClusterRequest_PublicIpAuto) isInitClusterRequest_PublicIpConfig() {}
+
 type InitClusterResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -95,7 +271,7 @@ type InitClusterResponse struct {
 func (x *InitClusterResponse) Reset() {
 	*x = InitClusterResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[1]
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -108,7 +284,7 @@ func (x *InitClusterResponse) String() string {
 func (*InitClusterResponse) ProtoMessage() {}
 
 func (x *InitClusterResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[1]
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -121,7 +297,7 @@ func (x *InitClusterResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use InitClusterResponse.ProtoReflect.Descriptor instead.
 func (*InitClusterResponse) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{1}
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{3}
 }
 
 func (x *InitClusterResponse) GetMachine() *MachineInfo {
@@ -143,7 +319,7 @@ type JoinClusterRequest struct {
 func (x *JoinClusterRequest) Reset() {
 	*x = JoinClusterRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[2]
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -156,7 +332,7 @@ func (x *JoinClusterRequest) String() string {
 func (*JoinClusterRequest) ProtoMessage() {}
 
 func (x *JoinClusterRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[2]
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -169,7 +345,7 @@ func (x *JoinClusterRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use JoinClusterRequest.ProtoReflect.Descriptor instead.
 func (*JoinClusterRequest) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{2}
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *JoinClusterRequest) GetMachine() *MachineInfo {
@@ -197,7 +373,7 @@ type TokenResponse struct {
 func (x *TokenResponse) Reset() {
 	*x = TokenResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[3]
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -210,7 +386,7 @@ func (x *TokenResponse) String() string {
 func (*TokenResponse) ProtoMessage() {}
 
 func (x *TokenResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[3]
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -223,7 +399,7 @@ func (x *TokenResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use TokenResponse.ProtoReflect.Descriptor instead.
 func (*TokenResponse) Descriptor() ([]byte, []int) {
-	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{3}
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *TokenResponse) GetToken() string {
@@ -233,6 +409,227 @@ func (x *TokenResponse) GetToken() string {
 	return ""
 }
 
+type Service struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id         string               `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Name       string               `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Mode       string               `protobuf:"bytes,3,opt,name=mode,proto3" json:"mode,omitempty"`
+	Containers []*Service_Container `protobuf:"bytes,4,rep,name=containers,proto3" json:"containers,omitempty"`
+}
+
+func (x *Service) Reset() {
+	*x = Service{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Service) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service) ProtoMessage() {}
+
+func (x *Service) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service.ProtoReflect.Descriptor instead.
+func (*Service) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *Service) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+func (x *Service) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *Service) GetMode() string {
+	if x != nil {
+		return x.Mode
+	}
+	return ""
+}
+
+func (x *Service) GetContainers() []*Service_Container {
+	if x != nil {
+		return x.Containers
+	}
+	return nil
+}
+
+type InspectServiceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *InspectServiceRequest) Reset() {
+	*x = InspectServiceRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *InspectServiceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InspectServiceRequest) ProtoMessage() {}
+
+func (x *InspectServiceRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use InspectServiceRequest.ProtoReflect.Descriptor instead.
+func (*InspectServiceRequest) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *InspectServiceRequest) GetId() string {
+	if x != nil {
+		return x.Id
+	}
+	return ""
+}
+
+type InspectServiceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Service *Service `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
+}
+
+func (x *InspectServiceResponse) Reset() {
+	*x = InspectServiceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *InspectServiceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InspectServiceResponse) ProtoMessage() {}
+
+func (x *InspectServiceResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use InspectServiceResponse.ProtoReflect.Descriptor instead.
+func (*InspectServiceResponse) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *InspectServiceResponse) GetService() *Service {
+	if x != nil {
+		return x.Service
+	}
+	return nil
+}
+
+type Service_Container struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	MachineId string `protobuf:"bytes,1,opt,name=machine_id,json=machineId,proto3" json:"machine_id,omitempty"`
+	// JSON encoded Docker types.Container.
+	Container []byte `protobuf:"bytes,2,opt,name=container,proto3" json:"container,omitempty"`
+}
+
+func (x *Service_Container) Reset() {
+	*x = Service_Container{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_internal_machine_api_pb_machine_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Service_Container) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Service_Container) ProtoMessage() {}
+
+func (x *Service_Container) ProtoReflect() protoreflect.Message {
+	mi := &file_internal_machine_api_pb_machine_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Service_Container.ProtoReflect.Descriptor instead.
+func (*Service_Container) Descriptor() ([]byte, []int) {
+	return file_internal_machine_api_pb_machine_proto_rawDescGZIP(), []int{6, 0}
+}
+
+func (x *Service_Container) GetMachineId() string {
+	if x != nil {
+		return x.MachineId
+	}
+	return ""
+}
+
+func (x *Service_Container) GetContainer() []byte {
+	if x != nil {
+		return x.Container
+	}
+	return nil
+}
+
 var File_internal_machine_api_pb_machine_proto protoreflect.FileDescriptor
 
 var file_internal_machine_api_pb_machine_proto_rawDesc = []byte{
@@ -242,52 +639,97 @@ var file_internal_machine_api_pb_machine_proto_rawDesc = []byte{
 	0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d,
 	0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x69, 0x6e, 0x74, 0x65, 0x72,
 	0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f,
-	0x70, 0x62, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a,
-	0x25, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x2f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7e, 0x0a, 0x12, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c,
-	0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b,
-	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x27,
-	0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x07,
-	0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x12, 0x1d, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x55, 0x73, 0x65, 0x72,
-	0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x22, 0x41, 0x0a, 0x13, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c,
-	0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a,
-	0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10,
-	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f,
-	0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x22, 0x79, 0x0a, 0x12, 0x4a, 0x6f, 0x69,
-	0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x2a, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e,
-	0x66, 0x6f, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x37, 0x0a, 0x0e, 0x6f,
-	0x74, 0x68, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e,
-	0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x61, 0x63, 0x68,
-	0x69, 0x6e, 0x65, 0x73, 0x22, 0x25, 0x0a, 0x0d, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x32, 0xf5, 0x01, 0x0a, 0x07,
-	0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x49, 0x6e, 0x69, 0x74, 0x43,
-	0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e, 0x69,
-	0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
-	0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x4a, 0x6f, 0x69,
-	0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4a,
-	0x6f, 0x69, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x12, 0x2e, 0x61, 0x70, 0x69,
-	0x2e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33,
-	0x0a, 0x07, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
-	0x79, 0x1a, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49,
-	0x6e, 0x66, 0x6f, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
-	0x6d, 0x2f, 0x70, 0x73, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x6b, 0x69, 0x2f, 0x75, 0x6e, 0x63,
-	0x6c, 0x6f, 0x75, 0x64, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x6d, 0x61,
-	0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x70, 0x62, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
+	0x85, 0x01, 0x0a, 0x0b, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12,
+	0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12,
+	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f,
+	0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72,
+	0x6b, 0x12, 0x24, 0x0a, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x70, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x52, 0x08, 0x70,
+	0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x70, 0x22, 0xae, 0x01, 0x0a, 0x0d, 0x4e, 0x65, 0x74, 0x77,
+	0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x25, 0x0a, 0x06, 0x73, 0x75, 0x62,
+	0x6e, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e,
+	0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x06, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74,
+	0x12, 0x2c, 0x0a, 0x0d, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69,
+	0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x07, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50,
+	0x52, 0x0c, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x70, 0x12, 0x29,
+	0x0a, 0x09, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x0b, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x09,
+	0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62,
+	0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70,
+	0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x22, 0xc3, 0x01, 0x0a, 0x12, 0x49, 0x6e, 0x69,
+	0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x20, 0x0a, 0x0b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x4e, 0x61, 0x6d,
+	0x65, 0x12, 0x27, 0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69,
+	0x78, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x12, 0x26, 0x0a, 0x09, 0x70, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x07, 0x2e,
+	0x61, 0x70, 0x69, 0x2e, 0x49, 0x50, 0x48, 0x00, 0x52, 0x08, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+	0x49, 0x70, 0x12, 0x26, 0x0a, 0x0e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x70, 0x5f,
+	0x61, 0x75, 0x74, 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x49, 0x70, 0x41, 0x75, 0x74, 0x6f, 0x42, 0x12, 0x0a, 0x10, 0x70, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x41,
+	0x0a, 0x13, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d, 0x61, 0x63,
+	0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e,
+	0x65, 0x22, 0x79, 0x0a, 0x12, 0x4a, 0x6f, 0x69, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x07, 0x6d, 0x61, 0x63, 0x68, 0x69,
+	0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4d,
+	0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x6d, 0x61, 0x63, 0x68,
+	0x69, 0x6e, 0x65, 0x12, 0x37, 0x0a, 0x0e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x63,
+	0x68, 0x69, 0x6e, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x61, 0x70,
+	0x69, 0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6f,
+	0x74, 0x68, 0x65, 0x72, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x73, 0x22, 0x25, 0x0a, 0x0d,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a,
+	0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f,
+	0x6b, 0x65, 0x6e, 0x22, 0xc3, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12,
+	0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12,
+	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x36, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61,
+	0x69, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x70,
+	0x69, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69,
+	0x6e, 0x65, 0x72, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x73, 0x1a,
+	0x48, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x0a,
+	0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x63,
+	0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
+	0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x27, 0x0a, 0x15, 0x49, 0x6e, 0x73,
+	0x70, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02,
+	0x69, 0x64, 0x22, 0x40, 0x0a, 0x16, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72,
+	0x76, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x07,
+	0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e,
+	0x61, 0x70, 0x69, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52, 0x07, 0x73, 0x65, 0x72,
+	0x76, 0x69, 0x63, 0x65, 0x32, 0xc0, 0x02, 0x0a, 0x07, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65,
+	0x12, 0x40, 0x0a, 0x0b, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12,
+	0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
+	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49,
+	0x6e, 0x69, 0x74, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x4a, 0x6f, 0x69, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
+	0x72, 0x12, 0x17, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x43, 0x6c, 0x75, 0x73,
+	0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70,
+	0x74, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x16, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x1a, 0x12, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x49, 0x6e, 0x73, 0x70, 0x65,
+	0x63, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x10, 0x2e, 0x61, 0x70, 0x69,
+	0x2e, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x49, 0x0a, 0x0e,
+	0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x1a,
+	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76,
+	0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x61, 0x70, 0x69,
+	0x2e, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x73, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x6b, 0x69,
+	0x2f, 0x75, 0x6e, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
+	0x6c, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x62,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -302,36 +744,51 @@ func file_internal_machine_api_pb_machine_proto_rawDescGZIP() []byte {
 	return file_internal_machine_api_pb_machine_proto_rawDescData
 }
 
-var file_internal_machine_api_pb_machine_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_internal_machine_api_pb_machine_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
 var file_internal_machine_api_pb_machine_proto_goTypes = []any{
-	(*InitClusterRequest)(nil),  // 0: api.InitClusterRequest
-	(*InitClusterResponse)(nil), // 1: api.InitClusterResponse
-	(*JoinClusterRequest)(nil),  // 2: api.JoinClusterRequest
-	(*TokenResponse)(nil),       // 3: api.TokenResponse
-	(*IPPrefix)(nil),            // 4: api.IPPrefix
-	(*User)(nil),                // 5: api.User
-	(*MachineInfo)(nil),         // 6: api.MachineInfo
-	(*emptypb.Empty)(nil),       // 7: google.protobuf.Empty
+	(*MachineInfo)(nil),            // 0: api.MachineInfo
+	(*NetworkConfig)(nil),          // 1: api.NetworkConfig
+	(*InitClusterRequest)(nil),     // 2: api.InitClusterRequest
+	(*InitClusterResponse)(nil),    // 3: api.InitClusterResponse
+	(*JoinClusterRequest)(nil),     // 4: api.JoinClusterRequest
+	(*TokenResponse)(nil),          // 5: api.TokenResponse
+	(*Service)(nil),                // 6: api.Service
+	(*InspectServiceRequest)(nil),  // 7: api.InspectServiceRequest
+	(*InspectServiceResponse)(nil), // 8: api.InspectServiceResponse
+	(*Service_Container)(nil),      // 9: api.Service.Container
+	(*IP)(nil),                     // 10: api.IP
+	(*IPPrefix)(nil),               // 11: api.IPPrefix
+	(*IPPort)(nil),                 // 12: api.IPPort
+	(*emptypb.Empty)(nil),          // 13: google.protobuf.Empty
 }
 var file_internal_machine_api_pb_machine_proto_depIdxs = []int32{
-	4, // 0: api.InitClusterRequest.network:type_name -> api.IPPrefix
-	5, // 1: api.InitClusterRequest.user:type_name -> api.User
-	6, // 2: api.InitClusterResponse.machine:type_name -> api.MachineInfo
-	6, // 3: api.JoinClusterRequest.machine:type_name -> api.MachineInfo
-	6, // 4: api.JoinClusterRequest.other_machines:type_name -> api.MachineInfo
-	0, // 5: api.Machine.InitCluster:input_type -> api.InitClusterRequest
-	2, // 6: api.Machine.JoinCluster:input_type -> api.JoinClusterRequest
-	7, // 7: api.Machine.Token:input_type -> google.protobuf.Empty
-	7, // 8: api.Machine.Inspect:input_type -> google.protobuf.Empty
-	1, // 9: api.Machine.InitCluster:output_type -> api.InitClusterResponse
-	7, // 10: api.Machine.JoinCluster:output_type -> google.protobuf.Empty
-	3, // 11: api.Machine.Token:output_type -> api.TokenResponse
-	6, // 12: api.Machine.Inspect:output_type -> api.MachineInfo
-	9, // [9:13] is the sub-list for method output_type
-	5, // [5:9] is the sub-list for method input_type
-	5, // [5:5] is the sub-list for extension type_name
-	5, // [5:5] is the sub-list for extension extendee
-	0, // [0:5] is the sub-list for field type_name
+	1,  // 0: api.MachineInfo.network:type_name -> api.NetworkConfig
+	10, // 1: api.MachineInfo.public_ip:type_name -> api.IP
+	11, // 2: api.NetworkConfig.subnet:type_name -> api.IPPrefix
+	10, // 3: api.NetworkConfig.management_ip:type_name -> api.IP
+	12, // 4: api.NetworkConfig.endpoints:type_name -> api.IPPort
+	11, // 5: api.InitClusterRequest.network:type_name -> api.IPPrefix
+	10, // 6: api.InitClusterRequest.public_ip:type_name -> api.IP
+	0,  // 7: api.InitClusterResponse.machine:type_name -> api.MachineInfo
+	0,  // 8: api.JoinClusterRequest.machine:type_name -> api.MachineInfo
+	0,  // 9: api.JoinClusterRequest.other_machines:type_name -> api.MachineInfo
+	9,  // 10: api.Service.containers:type_name -> api.Service.Container
+	6,  // 11: api.InspectServiceResponse.service:type_name -> api.Service
+	2,  // 12: api.Machine.InitCluster:input_type -> api.InitClusterRequest
+	4,  // 13: api.Machine.JoinCluster:input_type -> api.JoinClusterRequest
+	13, // 14: api.Machine.Token:input_type -> google.protobuf.Empty
+	13, // 15: api.Machine.Inspect:input_type -> google.protobuf.Empty
+	7,  // 16: api.Machine.InspectService:input_type -> api.InspectServiceRequest
+	3,  // 17: api.Machine.InitCluster:output_type -> api.InitClusterResponse
+	13, // 18: api.Machine.JoinCluster:output_type -> google.protobuf.Empty
+	5,  // 19: api.Machine.Token:output_type -> api.TokenResponse
+	0,  // 20: api.Machine.Inspect:output_type -> api.MachineInfo
+	8,  // 21: api.Machine.InspectService:output_type -> api.InspectServiceResponse
+	17, // [17:22] is the sub-list for method output_type
+	12, // [12:17] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
 }
 
 func init() { file_internal_machine_api_pb_machine_proto_init() }
@@ -340,10 +797,9 @@ func file_internal_machine_api_pb_machine_proto_init() {
 		return
 	}
 	file_internal_machine_api_pb_common_proto_init()
-	file_internal_machine_api_pb_cluster_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_internal_machine_api_pb_machine_proto_msgTypes[0].Exporter = func(v any, i int) any {
-			switch v := v.(*InitClusterRequest); i {
+			switch v := v.(*MachineInfo); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -355,7 +811,7 @@ func file_internal_machine_api_pb_machine_proto_init() {
 			}
 		}
 		file_internal_machine_api_pb_machine_proto_msgTypes[1].Exporter = func(v any, i int) any {
-			switch v := v.(*InitClusterResponse); i {
+			switch v := v.(*NetworkConfig); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -367,7 +823,7 @@ func file_internal_machine_api_pb_machine_proto_init() {
 			}
 		}
 		file_internal_machine_api_pb_machine_proto_msgTypes[2].Exporter = func(v any, i int) any {
-			switch v := v.(*JoinClusterRequest); i {
+			switch v := v.(*InitClusterRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -379,6 +835,30 @@ func file_internal_machine_api_pb_machine_proto_init() {
 			}
 		}
 		file_internal_machine_api_pb_machine_proto_msgTypes[3].Exporter = func(v any, i int) any {
+			switch v := v.(*InitClusterResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[4].Exporter = func(v any, i int) any {
+			switch v := v.(*JoinClusterRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[5].Exporter = func(v any, i int) any {
 			switch v := v.(*TokenResponse); i {
 			case 0:
 				return &v.state
@@ -390,6 +870,58 @@ func file_internal_machine_api_pb_machine_proto_init() {
 				return nil
 			}
 		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[6].Exporter = func(v any, i int) any {
+			switch v := v.(*Service); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[7].Exporter = func(v any, i int) any {
+			switch v := v.(*InspectServiceRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[8].Exporter = func(v any, i int) any {
+			switch v := v.(*InspectServiceResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_internal_machine_api_pb_machine_proto_msgTypes[9].Exporter = func(v any, i int) any {
+			switch v := v.(*Service_Container); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_internal_machine_api_pb_machine_proto_msgTypes[2].OneofWrappers = []any{
+		(*InitClusterRequest_PublicIp)(nil),
+		(*InitClusterRequest_PublicIpAuto)(nil),
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -397,7 +929,7 @@ func file_internal_machine_api_pb_machine_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_internal_machine_api_pb_machine_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   4,
+			NumMessages:   10,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

internal/machine/api/pb/machine.proto

@@ -6,19 +6,37 @@ option go_package = "github.com/psviderski/uncloud/internal/machine/api/pb";
 
 import "google/protobuf/empty.proto";
 import "internal/machine/api/pb/common.proto";
-import "internal/machine/api/pb/cluster.proto";
 
 service Machine {
   rpc InitCluster(InitClusterRequest) returns (InitClusterResponse);
   rpc JoinCluster(JoinClusterRequest) returns (google.protobuf.Empty);
   rpc Token(google.protobuf.Empty) returns (TokenResponse);
   rpc Inspect(google.protobuf.Empty) returns (MachineInfo);
+  rpc InspectService(InspectServiceRequest) returns (InspectServiceResponse);
+}
+
+message MachineInfo {
+  string id = 1;
+  string name = 2;
+  NetworkConfig network = 3;
+  IP public_ip = 4;
+}
+
+message NetworkConfig {
+  IPPrefix subnet = 1;
+  IP management_ip = 2;
+  repeated IPPort endpoints = 3;
+  bytes public_key = 4;
 }
 
 message InitClusterRequest {
   string machineName = 1;
   IPPrefix network = 2;
-  User user = 3;
+
+  oneof public_ip_config {
+    IP public_ip = 3;
+    bool public_ip_auto = 4;
+  }
 }
 
 message InitClusterResponse {
@@ -33,3 +51,25 @@ message JoinClusterRequest {
 message TokenResponse {
   string token = 1;
 }
+
+message Service {
+  string id = 1;
+  string name = 2;
+  string mode = 3;
+
+  message Container {
+    string machine_id = 1;
+    // JSON encoded Docker types.Container.
+    bytes container = 2;
+  }
+
+  repeated Container containers = 4;
+}
+
+message InspectServiceRequest {
+  string id = 1;
+}
+
+message InspectServiceResponse {
+  Service service = 1;
+}

internal/machine/api/pb/machine_grpc.pb.go

@@ -20,10 +20,11 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	Machine_InitCluster_FullMethodName = "/api.Machine/InitCluster"
-	Machine_JoinCluster_FullMethodName = "/api.Machine/JoinCluster"
-	Machine_Token_FullMethodName       = "/api.Machine/Token"
-	Machine_Inspect_FullMethodName     = "/api.Machine/Inspect"
+	Machine_InitCluster_FullMethodName    = "/api.Machine/InitCluster"
+	Machine_JoinCluster_FullMethodName    = "/api.Machine/JoinCluster"
+	Machine_Token_FullMethodName          = "/api.Machine/Token"
+	Machine_Inspect_FullMethodName        = "/api.Machine/Inspect"
+	Machine_InspectService_FullMethodName = "/api.Machine/InspectService"
 )
 
 // MachineClient is the client API for Machine service.
@@ -34,6 +35,7 @@ type MachineClient interface {
 	JoinCluster(ctx context.Context, in *JoinClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
 	Token(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TokenResponse, error)
 	Inspect(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MachineInfo, error)
+	InspectService(ctx context.Context, in *InspectServiceRequest, opts ...grpc.CallOption) (*InspectServiceResponse, error)
 }
 
 type machineClient struct {
@@ -84,6 +86,16 @@ func (c *machineClient) Inspect(ctx context.Context, in *emptypb.Empty, opts ...
 	return out, nil
 }
 
+func (c *machineClient) InspectService(ctx context.Context, in *InspectServiceRequest, opts ...grpc.CallOption) (*InspectServiceResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(InspectServiceResponse)
+	err := c.cc.Invoke(ctx, Machine_InspectService_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MachineServer is the server API for Machine service.
 // All implementations must embed UnimplementedMachineServer
 // for forward compatibility.
@@ -92,6 +104,7 @@ type MachineServer interface {
 	JoinCluster(context.Context, *JoinClusterRequest) (*emptypb.Empty, error)
 	Token(context.Context, *emptypb.Empty) (*TokenResponse, error)
 	Inspect(context.Context, *emptypb.Empty) (*MachineInfo, error)
+	InspectService(context.Context, *InspectServiceRequest) (*InspectServiceResponse, error)
 	mustEmbedUnimplementedMachineServer()
 }
 
@@ -114,6 +127,9 @@ func (UnimplementedMachineServer) Token(context.Context, *emptypb.Empty) (*Token
 func (UnimplementedMachineServer) Inspect(context.Context, *emptypb.Empty) (*MachineInfo, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Inspect not implemented")
 }
+func (UnimplementedMachineServer) InspectService(context.Context, *InspectServiceRequest) (*InspectServiceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method InspectService not implemented")
+}
 func (UnimplementedMachineServer) mustEmbedUnimplementedMachineServer() {}
 func (UnimplementedMachineServer) testEmbeddedByValue()                 {}
 
@@ -207,6 +223,24 @@ func _Machine_Inspect_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Machine_InspectService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(InspectServiceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MachineServer).InspectService(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Machine_InspectService_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MachineServer).InspectService(ctx, req.(*InspectServiceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Machine_ServiceDesc is the grpc.ServiceDesc for Machine service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -230,6 +264,10 @@ var Machine_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Inspect",
 			Handler:    _Machine_Inspect_Handler,
 		},
+		{
+			MethodName: "InspectService",
+			Handler:    _Machine_InspectService_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "internal/machine/api/pb/machine.proto",

internal/machine/api/proxy/backend.go

@@ -0,0 +1,144 @@
+package proxy
+
+import (
+	"fmt"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/encoding/protowire"
+	"google.golang.org/protobuf/proto"
+	"uncloud/internal/machine/api/pb"
+)
+
+// One2ManyResponder converts upstream responses into messages from upstreams, so that multiple
+// successful and failure responses might be returned in One2Many mode.
+type One2ManyResponder struct {
+	machine string
+}
+
+// AppendInfo is called to enhance response from the backend with additional data.
+//
+// AppendInfo enhances upstream response with machine metadata (target).
+//
+// This method depends on grpc protobuf response structure, each response should
+// look like:
+//
+//	message SomeResponse {
+//	  repeated SomeReply messages = 1; // please note field ID == 1
+//	}
+//
+//	message SomeReply {
+//	  common.Metadata metadata = 1;
+//	  <other fields go here ...>
+//	}
+//
+// As 'SomeReply' is repeated in 'SomeResponse', if we concatenate protobuf representation
+// of several 'SomeResponse' messages, we still get valid 'SomeResponse' representation but with more
+// entries (feature of protobuf binary representation).
+//
+// If we look at binary representation of any unary 'SomeResponse' message, it will always contain one
+// protobuf field with field ID 1 (see above) and type 2 (embedded message SomeReply is encoded
+// as string with length). So if we want to add fields to 'SomeReply', we can simply read field
+// header, adjust length for new 'SomeReply' representation, and prepend new field header.
+//
+// At the same time, we can add 'common.Metadata' structure to 'SomeReply' by simply
+// appending or prepending 'common.Metadata' as a single field. This requires 'metadata'
+// field to be not defined in original response. (This is due to the fact that protobuf message
+// representation is concatenation of each field representation).
+//
+// To build only single field (Metadata) we use helper message which contains exactly this
+// field with same field ID as in every other 'SomeReply':
+//
+//	message Empty {
+//	  common.Metadata metadata = 1;
+//	}
+//
+// As streaming replies are not wrapped into 'SomeResponse' with 'repeated', handling is simpler: we just
+// need to append Empty with details.
+//
+// So AppendInfo does the following: validates that response contains field ID 1 encoded as string,
+// cuts field header, rest is representation of some reply. Marshal 'Empty' as protobuf,
+// which builds 'common.Metadata' field, append it to original response message, build new header
+// for new length of some response, and add back new field header.
+func (b *One2ManyResponder) AppendInfo(streaming bool, resp []byte) ([]byte, error) {
+	payload, err := proto.Marshal(&pb.Empty{
+		Metadata: &pb.Metadata{
+			Machine: b.machine,
+		},
+	})
+
+	if streaming {
+		return append(resp, payload...), err
+	}
+
+	const (
+		metadataField = 1 // field number in proto definition for repeated response
+		metadataType  = 2 // "string" for embedded messages
+	)
+
+	// decode protobuf embedded header
+
+	typ, n1 := protowire.ConsumeVarint(resp)
+	if n1 < 0 {
+		return nil, protowire.ParseError(n1)
+	}
+
+	_, n2 := protowire.ConsumeVarint(resp[n1:]) // length
+	if n2 < 0 {
+		return nil, protowire.ParseError(n2)
+	}
+
+	if typ != (metadataField<<3)|metadataType {
+		return nil, fmt.Errorf("unexpected message format: %d", typ)
+	}
+
+	if n1+n2 > len(resp) {
+		return nil, fmt.Errorf("unexpected message size: %d", len(resp))
+	}
+
+	// cut off embedded message header
+	resp = resp[n1+n2:]
+	// build new embedded message header
+	prefix := protowire.AppendVarint(
+		protowire.AppendVarint(nil, (metadataField<<3)|metadataType),
+		uint64(len(resp)+len(payload)),
+	)
+	resp = append(prefix, resp...)
+
+	return append(resp, payload...), err
+}
+
+// BuildError converts upstream error into message from upstream, so that multiple
+// successful and failure responses might be returned.
+//
+// This simply relies on the fact that any response contains 'Empty' message.
+// So if 'Empty' is unmarshalled into any other reply message, all the fields
+// are undefined but 'Metadata':
+//
+//	message Empty {
+//	  common.Metadata metadata = 1;
+//	}
+//
+//	message EmptyResponse {
+//	  repeated Empty messages = 1;
+//	}
+//
+// Streaming responses are not wrapped into Empty, so we simply marshall EmptyResponse
+// message.
+func (b *One2ManyResponder) BuildError(streaming bool, err error) ([]byte, error) {
+	var resp proto.Message = &pb.Empty{
+		Metadata: &pb.Metadata{
+			Machine: b.machine,
+			Error:   err.Error(),
+			Status:  status.Convert(err).Proto(),
+		},
+	}
+
+	if !streaming {
+		resp = &pb.EmptyResponse{
+			Messages: []*pb.Empty{
+				resp.(*pb.Empty),
+			},
+		}
+	}
+
+	return proto.Marshal(resp)
+}

internal/machine/api/proxy/director.go

@@ -0,0 +1,125 @@
+package proxy
+
+import (
+	"context"
+	"github.com/siderolabs/grpc-proxy/proxy"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+	"sync"
+)
+
+// Director manages routing of gRPC requests between local and remote backends.
+type Director struct {
+	localBackend   *LocalBackend
+	remotePort     uint16
+	remoteBackends sync.Map
+	// mu synchronizes access to localAddress.
+	mu           sync.RWMutex
+	localAddress string
+}
+
+func NewDirector(localSockPath string, remotePort uint16) *Director {
+	return &Director{
+		localBackend: NewLocalBackend(localSockPath, ""),
+		remotePort:   remotePort,
+	}
+}
+
+// UpdateLocalAddress updates the local machine address used to identify which requests should be proxied
+// to the local gRPC server.
+func (d *Director) UpdateLocalAddress(addr string) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	d.localAddress = addr
+	// Replace the local backend with the one that has local address set.
+	d.localBackend = NewLocalBackend(d.localBackend.sockPath, addr)
+}
+
+// Director implements proxy.StreamDirector for grpc-proxy, routing requests to local or remote backends based
+// on gRPC metadata in the context. Each machine metadata is injected into the response messages by the proxy
+// if the request is proxied to multiple backends.
+func (d *Director) Director(ctx context.Context, fullMethodName string) (proxy.Mode, []proxy.Backend, error) {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
+		return proxy.One2One, []proxy.Backend{d.localBackend}, nil
+	}
+	// If the request is already proxied, send it to the local backend.
+	if _, ok = md["proxy-authority"]; ok {
+		return proxy.One2One, []proxy.Backend{d.localBackend}, nil
+	}
+	// If the request metadata doesn't contain machines to proxy to, send it to the local backend.
+	machines, ok := md["machines"]
+	if !ok {
+		return proxy.One2One, []proxy.Backend{d.localBackend}, nil
+	}
+	if len(machines) == 0 {
+		return proxy.One2One, nil, status.Error(codes.InvalidArgument, "no machines specified")
+	}
+
+	d.mu.RLock()
+	localAddress := d.localAddress
+	localBackend := d.localBackend
+	d.mu.RUnlock()
+
+	backends := make([]proxy.Backend, len(machines))
+	for i, addr := range machines {
+		if addr == localAddress {
+			backends[i] = localBackend
+			continue
+		}
+
+		backend, err := d.remoteBackend(addr)
+		if err != nil {
+			return proxy.One2One, nil, status.Error(codes.Internal, err.Error())
+		}
+		backends[i] = backend
+	}
+
+	if len(backends) == 1 {
+		return proxy.One2One, backends, nil
+	}
+	return proxy.One2Many, backends, nil
+}
+
+// remoteBackend returns a RemoteBackend for the given address from the cache or creates a new one.
+func (d *Director) remoteBackend(addr string) (*RemoteBackend, error) {
+	b, ok := d.remoteBackends.Load(addr)
+	if ok {
+		return b.(*RemoteBackend), nil
+	}
+
+	backend, err := NewRemoteBackend(addr, d.remotePort)
+	if err != nil {
+		return nil, err
+	}
+	existing, loaded := d.remoteBackends.LoadOrStore(addr, backend)
+	if loaded {
+		// A concurrent remoteBackend call built a different backend.
+		backend.Close()
+		return existing.(*RemoteBackend), nil
+	}
+
+	return backend, nil
+}
+
+// FlushRemoteBackends closes all remote backend connections and removes them from the cache.
+func (d *Director) FlushRemoteBackends() {
+	d.remoteBackends.Range(func(key, value interface{}) bool {
+		backend, ok := value.(*RemoteBackend)
+		if !ok {
+			return true
+		}
+
+		backend.Close()
+		d.remoteBackends.Delete(key)
+		return true
+	})
+}
+
+// Close closes all backend connections.
+func (d *Director) Close() {
+	d.localBackend.Close()
+	d.FlushRemoteBackends()
+}

internal/machine/api/proxy/local.go

@@ -0,0 +1,75 @@
+package proxy
+
+import (
+	"context"
+	"github.com/siderolabs/grpc-proxy/proxy"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
+	"sync"
+)
+
+// LocalBackend is a proxy.One2ManyResponder implementation that proxies to a local gRPC server listening on a Unix socket.
+type LocalBackend struct {
+	One2ManyResponder
+	sockPath string
+
+	mu   sync.RWMutex
+	conn *grpc.ClientConn
+}
+
+var _ proxy.Backend = (*LocalBackend)(nil)
+
+// NewLocalBackend returns a new LocalBackend for the given Unix socket path. The addr parameter is the local address
+// of the current machine which could be empty if it's not known. The address is used to populate response metadata
+// in one2many mode.
+func NewLocalBackend(sockPath, addr string) *LocalBackend {
+	return &LocalBackend{
+		One2ManyResponder: One2ManyResponder{
+			machine: addr,
+		},
+		sockPath: sockPath,
+	}
+}
+
+func (b *LocalBackend) String() string {
+	return b.machine
+}
+
+// GetConnection returns a gRPC connection to the local server listening on the Unix socket.
+func (b *LocalBackend) GetConnection(ctx context.Context, _ string) (context.Context, *grpc.ClientConn, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	outCtx := metadata.NewOutgoingContext(ctx, md)
+
+	b.mu.RLock()
+	if b.conn != nil {
+		defer b.mu.RUnlock()
+		return outCtx, b.conn, nil
+	}
+	b.mu.RUnlock()
+
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	var err error
+	b.conn, err = grpc.NewClient(
+		"unix://"+b.sockPath,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultCallOptions(
+			grpc.ForceCodecV2(proxy.Codec()),
+		),
+	)
+
+	return outCtx, b.conn, err
+}
+
+// Close closes the upstream gRPC connection.
+func (b *LocalBackend) Close() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if b.conn != nil {
+		b.conn.Close()
+		b.conn = nil
+	}
+}

internal/machine/api/proxy/remote.go

@@ -0,0 +1,109 @@
+package proxy
+
+import (
+	"context"
+	"fmt"
+	"github.com/siderolabs/grpc-proxy/proxy"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/backoff"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
+	"net/netip"
+	"sync"
+	"time"
+)
+
+// RemoteBackend is a proxy.One2ManyResponder implementation that proxies to a remote gRPC server, injecting machine metadata
+// into the response.
+//
+// Based on the Talos apid implementation:
+// https://github.com/siderolabs/talos/blob/59a78da42cdea8fbccc35d0851f9b0eef928261b/internal/app/apid/pkg/backend/apid.go
+type RemoteBackend struct {
+	One2ManyResponder
+	target string
+
+	mu   sync.RWMutex
+	conn *grpc.ClientConn
+}
+
+var _ proxy.Backend = (*RemoteBackend)(nil)
+
+// NewRemoteBackend creates a new instance of RemoteBackend for the given IPv6 address and port.
+func NewRemoteBackend(addr string, port uint16) (*RemoteBackend, error) {
+	ip, err := netip.ParseAddr(addr)
+	if err != nil || !ip.Is6() {
+		return nil, fmt.Errorf("address must be a valid IPv6 address: %s", addr)
+	}
+
+	return &RemoteBackend{
+		One2ManyResponder: One2ManyResponder{
+			machine: addr,
+		},
+		target: netip.AddrPortFrom(ip, port).String(),
+	}, nil
+}
+
+func (b *RemoteBackend) String() string {
+	return b.machine
+}
+
+// GetConnection returns a gRPC connection to the remote server.
+func (b *RemoteBackend) GetConnection(ctx context.Context, _ string) (context.Context, *grpc.ClientConn, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if authority := md[":authority"]; len(authority) > 0 {
+		md.Set("proxy-authority", authority...)
+	} else {
+		md.Set("proxy-authority", "unknown")
+	}
+	delete(md, ":authority")
+	delete(md, "machines")
+
+	outCtx := metadata.NewOutgoingContext(ctx, md)
+
+	b.mu.RLock()
+	if b.conn != nil {
+		defer b.mu.RUnlock()
+		return outCtx, b.conn, nil
+	}
+	b.mu.RUnlock()
+
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	// Override the max delay to avoid excessive backoff when the another node is unavailable, e.g. rebooted
+	// or the WireGuard connection is temporary down.
+	//
+	// Default max delay is 2 minutes, which is too long for our use case.
+	backoffConfig := backoff.DefaultConfig
+	// The maximum wait time between attempts.
+	backoffConfig.MaxDelay = 15 * time.Second
+
+	var err error
+	b.conn, err = grpc.NewClient(
+		b.target,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithConnectParams(grpc.ConnectParams{
+			Backoff: backoffConfig,
+			// Not published as a constant in gRPC library.
+			// See: https://github.com/grpc/grpc-go/blob/d5dee5fdbdeb52f6ea10b37b2cc7ce37814642d7/clientconn.go#L55-L56
+			// Each connection attempt can take up to MinConnectTimeout.
+			MinConnectTimeout: 20 * time.Second,
+		}),
+		grpc.WithDefaultCallOptions(
+			grpc.ForceCodecV2(proxy.Codec()),
+		),
+	)
+
+	return outCtx, b.conn, err
+}
+
+// Close closes the upstream gRPC connection.
+func (b *RemoteBackend) Close() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if b.conn != nil {
+		b.conn.Close()
+		b.conn = nil
+	}
+}

internal/machine/api/vendor/google/rpc/status.proto

@@ -0,0 +1,49 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package google.rpc;
+
+import "google/protobuf/any.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/rpc/status;status";
+option java_multiple_files = true;
+option java_outer_classname = "StatusProto";
+option java_package = "com.google.rpc";
+option objc_class_prefix = "RPC";
+
+// The `Status` type defines a logical error model that is suitable for
+// different programming environments, including REST APIs and RPC APIs. It is
+// used by [gRPC](https://github.com/grpc). Each `Status` message contains
+// three pieces of data: error code, error message, and error details.
+//
+// You can find out more about this error model and how to work with it in the
+// [API Design Guide](https://cloud.google.com/apis/design/errors).
+message Status {
+  // The status code, which should be an enum value of
+  // [google.rpc.Code][google.rpc.Code].
+  int32 code = 1;
+
+  // A developer-facing error message, which should be in English. Any
+  // user-facing error message should be localized and sent in the
+  // [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+  // by the client.
+  string message = 2;
+
+  // A list of messages that carry the error details.  There is a common set of
+  // message types for APIs to use.
+  repeated google.protobuf.Any details = 3;
+}

internal/machine/caddyfile/config.go

@@ -0,0 +1,163 @@
+package caddyfile
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/caddyserver/caddy/v2"
+	"github.com/caddyserver/caddy/v2/caddyconfig"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
+	"github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy"
+	"log/slog"
+	"maps"
+	"net"
+	"net/http"
+	"slices"
+	"strconv"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/docker"
+)
+
+func GenerateConfig(containers []api.Container, verifyResponse string) (*caddy.Config, error) {
+	// Maps hostnames to lists of upstreams (container IP:port pairs).
+	httpHostUpstreams := make(map[string][]string)
+	httpsHostUpstreams := make(map[string][]string)
+	for _, ctr := range containers {
+		logger := slog.With("container", ctr.ID)
+		network, ok := ctr.NetworkSettings.Networks[docker.NetworkName]
+		if !ok {
+			// Container is not connected to the uncloud Docker network (could be host network).
+			continue
+		}
+		if network.IPAddress == "" {
+			logger.Error("Container has no IPv4 address.")
+			continue
+		}
+
+		ports, err := ctr.ServicePorts()
+		if err != nil {
+			logger.Error("Failed to parse service ports for container.", "err", err)
+			continue
+		}
+
+		for _, port := range ports {
+			switch port.Protocol {
+			case api.ProtocolHTTP:
+				upstream := net.JoinHostPort(network.IPAddress, strconv.Itoa(int(port.ContainerPort)))
+				httpHostUpstreams[port.Hostname] = append(httpHostUpstreams[port.Hostname], upstream)
+			case api.ProtocolHTTPS:
+				upstream := net.JoinHostPort(network.IPAddress, strconv.Itoa(int(port.ContainerPort)))
+				httpsHostUpstreams[port.Hostname] = append(httpsHostUpstreams[port.Hostname], upstream)
+			default:
+				// TODO: implement L4 ingress routing for TCP and UDP.
+				logger.Error("Unsupported protocol for ingress port.", "port", port)
+				continue
+			}
+		}
+	}
+
+	var warnings []caddyconfig.Warning
+	servers := make(map[string]*caddyhttp.Server)
+	servers["http"] = &caddyhttp.Server{
+		Listen: []string{fmt.Sprintf(":%d", caddyhttp.DefaultHTTPPort)},
+		Routes: append(
+			hostUpstreamsToRoutes(httpHostUpstreams, &warnings),
+			// Add a route to respond with a static verification response at the /.uncloud-verify path.
+			verificationRoute(verifyResponse, &warnings),
+		),
+	}
+	servers["https"] = &caddyhttp.Server{
+		Listen: []string{fmt.Sprintf(":%d", caddyhttp.DefaultHTTPSPort)},
+		Routes: hostUpstreamsToRoutes(httpsHostUpstreams, &warnings),
+	}
+
+	httpApp := caddyhttp.App{
+		Servers: servers,
+	}
+	config := &caddy.Config{
+		AppsRaw: caddy.ModuleMap{
+			"http": caddyconfig.JSON(httpApp, &warnings),
+		},
+	}
+
+	var err error
+	if len(warnings) > 0 {
+		// warnings only contains errors from JSON marshaling, which are highly unlikely with correct code.
+		for _, w := range warnings {
+			err = errors.Join(err, errors.New(w.Message))
+		}
+		return nil, fmt.Errorf("marshal Caddy configuration: %w", err)
+	}
+
+	return config, nil
+}
+
+// hostUpstreamsToRoutes converts a map of hostnames to upstreams to a list of Caddy routes.
+func hostUpstreamsToRoutes(hostUpstreams map[string][]string, warnings *[]caddyconfig.Warning) []caddyhttp.Route {
+	// Sort hostnames for deterministic output.
+	hostnames := slices.Collect(maps.Keys(hostUpstreams))
+	slices.Sort(hostnames)
+
+	routes := make([]caddyhttp.Route, 0, len(hostUpstreams))
+	for _, hostname := range hostnames {
+		upstreams := hostUpstreams[hostname]
+		upstreamPool := make([]*reverseproxy.Upstream, len(upstreams))
+		for i, upstream := range upstreams {
+			upstreamPool[i] = &reverseproxy.Upstream{
+				Dial: upstream,
+			}
+		}
+		handler := &reverseproxy.Handler{
+			Upstreams: upstreamPool,
+		}
+
+		routes = append(routes, caddyhttp.Route{
+			MatcherSetsRaw: caddyhttp.RawMatcherSets{
+				{
+					"host": caddyconfig.JSON(caddyhttp.MatchHost{hostname}, warnings),
+				},
+			},
+			HandlersRaw: []json.RawMessage{
+				caddyconfig.JSONModuleObject(handler, "handler", "reverse_proxy", warnings),
+			},
+		})
+	}
+	return routes
+}
+
+// verificationRoute returns a Caddy route that responds with the given static response at the /.uncloud-verify path.
+func verificationRoute(response string, warnings *[]caddyconfig.Warning) caddyhttp.Route {
+	// Return the following route:
+	// {
+	//   "match": [
+	//     {
+	//       "path": [
+	//         "/.uncloud-verify"
+	//       ]
+	//     }
+	//   ],
+	//   "handle": [
+	//     {
+	//       "handler": "static_response",
+	//       "body": "<response>",
+	//       "status_code": 200
+	//     }
+	//   ]
+	// }
+
+	staticResponse := caddyhttp.StaticResponse{
+		StatusCode: caddyhttp.WeakString(strconv.Itoa(http.StatusOK)),
+		Body:       response,
+	}
+
+	return caddyhttp.Route{
+		MatcherSetsRaw: caddyhttp.RawMatcherSets{
+			{
+				"path": caddyconfig.JSON(caddyhttp.MatchPath{VerifyPath}, warnings),
+			},
+		},
+		HandlersRaw: []json.RawMessage{
+			caddyconfig.JSONModuleObject(staticResponse, "handler", "static_response", warnings),
+		},
+	}
+}

internal/machine/caddyfile/config_test.go

@@ -0,0 +1,365 @@
+package caddyfile
+
+import (
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/docker"
+)
+
+func TestGenerateConfig(t *testing.T) {
+	tests := []struct {
+		name       string
+		containers []api.Container
+		want       string
+		wantErr    bool
+	}{
+		{
+			name:       "empty containers",
+			containers: []api.Container{},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [{
+                            "match": [{"path": ["/.uncloud-verify"]}],
+                            "handle": [{
+								"body": "verification-response-body",
+								"handler": "static_response",
+								"status_code": 200
+							}]
+                        }]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+				}
+			}`,
+			wantErr: false,
+		},
+
+		{
+			name: "HTTP container",
+			containers: []api.Container{
+				newContainer("10.210.0.2", "app.example.com:8080/http"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [
+                            {
+                                "match": [{"host": ["app.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [{"dial": "10.210.0.2:8080"}]
+                                }]
+                            },
+                            {
+                                "match": [{"path": ["/.uncloud-verify"]}],
+                                "handle": [{
+                                    "body": "verification-response-body",
+                                    "handler": "static_response",
+                                    "status_code": 200
+                                }]
+                            }
+                        ]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "load balancing multiple containers",
+			containers: []api.Container{
+				newContainer("10.210.0.2", "app.example.com:8080/http"),
+				newContainer("10.210.0.3", "app.example.com:8080/http"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [
+                            {
+                                "match": [{"host": ["app.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [
+                                        {"dial": "10.210.0.2:8080"},
+                                        {"dial": "10.210.0.3:8080"}
+                                    ]
+                                }]
+                            },
+                            {
+                                "match": [{"path": ["/.uncloud-verify"]}],
+                                "handle": [{
+                                    "body": "verification-response-body",
+                                    "handler": "static_response",
+                                    "status_code": 200
+                                }]
+                            }
+                        ]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "HTTPS container",
+			containers: []api.Container{
+				newContainer("10.210.0.2", "secure.example.com:8000/https"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [
+                            {
+                                "match": [{"path": ["/.uncloud-verify"]}],
+                                "handle": [{
+                                    "body": "verification-response-body",
+                                    "handler": "static_response",
+                                    "status_code": 200
+                                }]
+                            }
+                        ]
+                    },
+                    "https": {
+                        "listen": [":443"],
+                        "routes": [
+                            {
+                                "match": [{"host": ["secure.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [{"dial": "10.210.0.2:8000"}]
+                                }]
+                            }
+                        ]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "mixed HTTP and HTTPS",
+			containers: []api.Container{
+				newContainer("10.210.0.2",
+					"app.example.com:8080/http",
+					"web.example.com:8000/http"),
+				newContainer("10.210.0.3",
+					"app.example.com:8080/http",
+					"secure.example.com:8888/https"),
+				newContainer("10.210.0.4",
+					"web.example.com:8000/http",
+					"secure.example.com:8888/https"),
+				newContainer("10.210.0.5",
+					"app.example.com:8080/http",
+					"web.example.com:8000/http",
+					"secure.example.com:8888/https"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [
+                            {
+                                "match": [{"host": ["app.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [
+										{"dial": "10.210.0.2:8080"},
+										{"dial": "10.210.0.3:8080"},
+										{"dial": "10.210.0.5:8080"}
+									]
+                                }]
+                            },
+							{
+                                "match": [{"host": ["web.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [
+										{"dial": "10.210.0.2:8000"},
+										{"dial": "10.210.0.4:8000"},
+										{"dial": "10.210.0.5:8000"}
+									]
+                                }]
+                            },
+                            {
+                                "match": [{"path": ["/.uncloud-verify"]}],
+                                "handle": [{
+                                    "body": "verification-response-body",
+                                    "handler": "static_response",
+                                    "status_code": 200
+                                }]
+                            }
+                        ]
+                    },
+                    "https": {
+                        "listen": [":443"],
+                        "routes": [
+                            {
+                                "match": [{"host": ["secure.example.com"]}],
+                                "handle": [{
+                                    "handler": "reverse_proxy",
+                                    "upstreams": [
+										{"dial": "10.210.0.3:8888"},
+										{"dial": "10.210.0.4:8888"},
+										{"dial": "10.210.0.5:8888"}
+									]
+                                }]
+                            }
+                        ]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "container without uncloud network ignored",
+			containers: []api.Container{
+				newContainerWithoutNetwork("ignored.example.com:8080/http"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [{
+                            "match": [{"path": ["/.uncloud-verify"]}],
+                            "handle": [{
+                                "body": "verification-response-body",
+                                "handler": "static_response",
+                                "status_code": 200
+                            }]
+                        }]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "container with invalid port ignored",
+			containers: []api.Container{
+				newContainer("10.210.0.2", "invalid-port"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [{
+                            "match": [{"path": ["/.uncloud-verify"]}],
+                            "handle": [{
+                                "body": "verification-response-body",
+                                "handler": "static_response",
+                                "status_code": 200
+                            }]
+                        }]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+		{
+			name: "containers with unsupported protocols ignored",
+			containers: []api.Container{
+				newContainer("10.210.0.2", "5000/tcp"),
+				newContainer("10.210.0.3", "5000/udp"),
+				newContainer("10.210.0.4", "80:8080/tcp@host"),
+			},
+			want: `{
+                "servers": {
+                    "http": {
+                        "listen": [":80"],
+                        "routes": [{
+                            "match": [{"path": ["/.uncloud-verify"]}],
+                            "handle": [{
+                                "body": "verification-response-body",
+                                "handler": "static_response",
+                                "status_code": 200
+                            }]
+                        }]
+                    },
+                    "https": {
+                        "listen": [":443"]
+                    }
+                }
+            }`,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			config, err := GenerateConfig(tt.containers, "verification-response-body")
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			require.Len(t, config.AppsRaw, 1, "Expected one http app")
+			require.Contains(t, config.AppsRaw, "http", "Expected http app")
+
+			assert.JSONEq(t, tt.want, string(config.AppsRaw["http"]), "Generated Caddy app config doesn't match")
+		})
+	}
+}
+
+func newContainer(ip string, ports ...string) api.Container {
+	portsLabel := strings.Join(ports, ",")
+	return api.Container{
+		ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{},
+			NetworkSettings: &types.NetworkSettings{
+				Networks: map[string]*network.EndpointSettings{
+					docker.NetworkName: {
+						IPAddress: ip,
+					},
+				},
+			},
+			Config: &container.Config{
+				Labels: map[string]string{
+					api.LabelServicePorts: portsLabel,
+				},
+			},
+		},
+	}
+}
+
+func newContainerWithoutNetwork(ports ...string) api.Container {
+	portsLabel := strings.Join(ports, ",")
+	return api.Container{
+		ContainerJSON: types.ContainerJSON{
+			ContainerJSONBase: &types.ContainerJSONBase{},
+			NetworkSettings: &types.NetworkSettings{
+				Networks: map[string]*network.EndpointSettings{
+					"other-network": {
+						IPAddress: "172.17.0.2",
+					},
+				},
+			},
+			Config: &container.Config{
+				Labels: map[string]string{
+					api.LabelServicePorts: portsLabel,
+				},
+			},
+		},
+	}
+}

internal/machine/caddyfile/controller.go

@@ -0,0 +1,119 @@
+package caddyfile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"uncloud/internal/api"
+	"uncloud/internal/fs"
+	"uncloud/internal/machine/store"
+)
+
+const (
+	CaddyGroup = "uncloud"
+	VerifyPath = "/.uncloud-verify"
+)
+
+// Controller monitors container changes in the cluster store and generates a configuration file for Caddy reverse
+// proxy. The generated Caddyfile allows Caddy to route external traffic to service containers across the internal
+// network.
+type Controller struct {
+	store          *store.Store
+	path           string
+	verifyResponse string
+}
+
+func NewController(store *store.Store, path string, verifyResponse string) (*Controller, error) {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0750); err != nil {
+		return nil, fmt.Errorf("create parent directory for Caddy configuration '%s': %w", dir, err)
+	}
+	if err := fs.Chown(dir, "", CaddyGroup); err != nil {
+		return nil, fmt.Errorf("change owner of parent directory for Caddy configuration '%s': %w", dir, err)
+	}
+
+	return &Controller{
+		store:          store,
+		path:           path,
+		verifyResponse: verifyResponse,
+	}, nil
+}
+
+func (c *Controller) Run(ctx context.Context) error {
+	containerRecords, changes, err := c.store.SubscribeContainers(ctx)
+	if err != nil {
+		return fmt.Errorf("subscribe to container changes: %w", err)
+	}
+	slog.Info("Subscribed to container changes in the cluster to generate Caddy configuration.")
+
+	containers, err := c.filterAvailableContainers(containerRecords)
+	if err != nil {
+		return fmt.Errorf("filter available containers: %w", err)
+	}
+	if err = c.generateConfig(containers); err != nil {
+		return fmt.Errorf("generate Caddy configuration: %w", err)
+	}
+
+	for {
+		select {
+		case _, ok := <-changes:
+			if !ok {
+				return fmt.Errorf("containers subscription failed")
+			}
+			slog.Debug("Cluster containers changed, updating Caddy configuration.")
+
+			containerRecords, err = c.store.ListContainers(ctx, store.ListOptions{})
+			if err != nil {
+				slog.Error("Failed to list containers.", "err", err)
+				continue
+			}
+			containers, err = c.filterAvailableContainers(containerRecords)
+			if err != nil {
+				slog.Error("Failed to filter available containers.", "err", err)
+				continue
+			}
+			if err = c.generateConfig(containers); err != nil {
+				slog.Error("Failed to generate Caddy configuration.", "err", err)
+			}
+
+			slog.Debug("Updated Caddy configuration.", "path", c.path)
+		case <-ctx.Done():
+			return nil
+		}
+	}
+}
+
+// filterAvailableContainers filters out containers from this machine that are likely unavailable. The availability
+// is determined by the cluster membership state of the machine that the container is running on.
+// TODO: implement machine membership check using Corrossion Admin client.
+func (c *Controller) filterAvailableContainers(containerRecords []store.ContainerRecord) ([]api.Container, error) {
+	containers := make([]api.Container, len(containerRecords))
+	for i, cr := range containerRecords {
+		containers[i] = cr.Container
+	}
+	return containers, nil
+}
+
+func (c *Controller) generateConfig(containers []api.Container) error {
+	config, err := GenerateConfig(containers, c.verifyResponse)
+	if err != nil {
+		return err
+	}
+
+	configBytes, err := json.MarshalIndent(config, "", "    ")
+	if err != nil {
+		return fmt.Errorf("marshal Caddy configuration: %w", err)
+	}
+
+	if err = os.WriteFile(c.path, configBytes, 0640); err != nil {
+		return fmt.Errorf("write Caddy configuration to file '%s': %w", c.path, err)
+	}
+	if err = fs.Chown(c.path, "", CaddyGroup); err != nil {
+		return fmt.Errorf("change owner of Caddy configuration file '%s': %w", c.path, err)
+	}
+
+	return nil
+}

internal/machine/cluster/cluster.go

@@ -3,130 +3,165 @@ package cluster
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/emptypb"
 	"log/slog"
 	"net/netip"
+	"time"
+	"uncloud/internal/corrosion"
 	"uncloud/internal/machine/api/pb"
 	"uncloud/internal/machine/network"
+	"uncloud/internal/machine/store"
 	"uncloud/internal/secret"
 )
 
 type Cluster struct {
 	pb.UnimplementedClusterServer
 
-	state *State
-
-	// TODO: temporary channel until the state is replaced with networkDB.
-	newMachinesCh chan *pb.MachineInfo
+	store      *store.Store
+	corroAdmin *corrosion.AdminClient
+	// machineID is the ID of the current machine that is running the cluster service.
+	machineID string
 }
 
-func NewCluster(state *State) *Cluster {
+func NewCluster(store *store.Store, corroAdmin *corrosion.AdminClient) *Cluster {
 	return &Cluster{
-		state:         state,
-		newMachinesCh: make(chan *pb.MachineInfo, 1),
+		store:      store,
+		corroAdmin: corroAdmin,
 	}
 }
 
-func (c *Cluster) SetState(state *State) {
-	c.state = state
+// UpdateMachineID updates the current machine ID that is running the cluster service.
+func (c *Cluster) UpdateMachineID(mid string) {
+	c.machineID = mid
 }
 
-func (c *Cluster) Network() (netip.Prefix, error) {
-	if c.state == nil {
-		return netip.Prefix{}, status.Error(codes.FailedPrecondition, "cluster is not initialized")
+func (c *Cluster) Init(ctx context.Context, network netip.Prefix) error {
+	initialised, err := c.Initialised(ctx)
+	if err != nil {
+		return err
+	}
+	if initialised {
+		return fmt.Errorf("cluster is already initialised")
 	}
 
-	if c.state.State.Network == nil {
-		return netip.Prefix{}, fmt.Errorf("network not set")
+	if err = c.store.Put(ctx, "network", network.String()); err != nil {
+		return fmt.Errorf("put network to store: %w", err)
 	}
-	return c.state.State.Network.ToPrefix()
-}
-
-func (c *Cluster) SetNetwork(network *pb.IPPrefix) error {
-	if c.state == nil {
-		return status.Error(codes.FailedPrecondition, "cluster is not initialized")
+	if err = c.store.Put(ctx, "created_at", time.Now().UTC().Format(time.RFC3339)); err != nil {
+		return fmt.Errorf("put created_at to store: %w", err)
 	}
-
-	if c.state.State.Network != nil {
-		return fmt.Errorf("network already set and cannot be changed")
-	}
-	if network == nil {
-		return fmt.Errorf("network not set")
-	}
-	c.state.State.Network = network
 	return nil
 }
 
-// TODO: this is a temporary watcher for PoC until the state is state is replaced with networkDB.
-func (c *Cluster) WatchNewMachines() <-chan *pb.MachineInfo {
-	return c.newMachinesCh
+func (c *Cluster) Initialised(ctx context.Context) (bool, error) {
+	var createdAt string
+	if err := c.store.Get(ctx, "created_at", &createdAt); err != nil {
+		if errors.Is(err, store.ErrKeyNotFound) {
+			return false, nil
+		}
+		return false, status.Errorf(codes.Internal, "get created_at from store: %v", err)
+	}
+	return true, nil
+}
+
+func (c *Cluster) checkInitialised(ctx context.Context) error {
+	initialised, err := c.Initialised(ctx)
+	if err != nil {
+		return err
+	}
+	if !initialised {
+		return status.Error(codes.FailedPrecondition, "cluster is not initialised")
+	}
+	return nil
+}
+
+func (c *Cluster) Network(ctx context.Context) (netip.Prefix, error) {
+	if err := c.checkInitialised(ctx); err != nil {
+		return netip.Prefix{}, err
+	}
+
+	var net string
+	if err := c.store.Get(ctx, "network", &net); err != nil {
+		return netip.Prefix{}, status.Errorf(codes.Internal, "get network from store: %v", err)
+	}
+	prefix, err := netip.ParsePrefix(net)
+	if err != nil {
+		return netip.Prefix{}, status.Errorf(codes.Internal, "parse network prefix: %v", err)
+	}
+	return prefix, nil
 }
 
 // AddMachine adds a machine to the cluster.
 func (c *Cluster) AddMachine(ctx context.Context, req *pb.AddMachineRequest) (*pb.AddMachineResponse, error) {
-	if c.state == nil {
-		return nil, status.Error(codes.FailedPrecondition, "cluster is not initialized")
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
 	}
 
-	if err := req.Validate(); err != nil {
+	if req.Network == nil {
+		return nil, status.Error(codes.InvalidArgument, "network not set")
+	}
+	if err := req.Network.Validate(); err != nil {
 		return nil, err
 	}
 	if len(req.Network.Endpoints) == 0 {
 		return nil, status.Error(codes.InvalidArgument, "endpoints not set")
 	}
+	if req.PublicIp != nil {
+		ip, err := req.PublicIp.ToAddr()
+		if err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "invalid public IP: %v", err)
+		}
+		if !ip.IsValid() {
+			return nil, status.Error(codes.InvalidArgument, "invalid public IP")
+		}
+	}
 
-	machines := c.state.State.Machines
+	machines, err := c.store.ListMachines(ctx)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "list machines: %v", err)
+	}
 	allocatedSubnets := make([]netip.Prefix, len(machines))
-	var err error
-	i := 0
-	for _, m := range machines {
+	for i, m := range machines {
 		if req.Name != "" && m.Name == req.Name {
 			return nil, status.Errorf(codes.AlreadyExists, "machine with name %q already exists", req.Name)
 		}
-		if m.Network.ManagementIp != nil && req.Network.ManagementIp != nil &&
-			m.Network.ManagementIp.Equal(req.Network.ManagementIp) {
+		if req.Network.ManagementIp != nil && req.Network.ManagementIp.Equal(m.Network.ManagementIp) {
 			manageIP, _ := req.Network.ManagementIp.ToAddr()
-			return nil, status.Errorf(codes.AlreadyExists, "machine with management IP %q already exists", manageIP)
+			return nil, status.Errorf(
+				codes.AlreadyExists, "machine with management IP %q already exists under the name %q",
+				manageIP, m.Name,
+			)
 		}
 		if bytes.Equal(m.Network.PublicKey, req.Network.PublicKey) {
 			publicKey := secret.Secret(m.Network.PublicKey)
-			return nil, status.Errorf(codes.AlreadyExists, "machine with public key %q already exists", publicKey)
+			return nil, status.Errorf(
+				codes.AlreadyExists, "machine with public key %q already exists under the name %q",
+				publicKey, m.Name,
+			)
 		}
-
-		if allocatedSubnets[i], err = m.Network.Subnet.ToPrefix(); err != nil {
-			return nil, err
-		}
-		i++
+		allocatedSubnets[i], _ = m.Network.Subnet.ToPrefix()
 	}
 
 	mid, err := NewMachineID()
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "generate machine ID: %v", err)
 	}
+	name := req.Name
+	if name == "" {
+		if name, err = NewRandomMachineName(); err != nil {
+			return nil, status.Errorf(codes.Internal, "generate machine name: %v", err)
+		}
+	}
 	manageIP := req.Network.ManagementIp
 	if manageIP == nil {
 		manageIP = pb.NewIP(network.ManagementIP(req.Network.PublicKey))
 	}
-	m := &pb.MachineInfo{
-		Id:   mid,
-		Name: req.Name,
-		Network: &pb.NetworkConfig{
-			ManagementIp: manageIP,
-			PublicKey:    req.Network.PublicKey,
-		},
-	}
-	if m.Name == "" {
-		m.Name, err = NewRandomMachineName()
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "generate machine name: %v", err)
-		}
-	}
-
-	clusterNetwork, err := c.Network()
+	// Allocate a subnet for the machine from the cluster network.
+	clusterNetwork, err := c.Network(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "get cluster network: %v", err)
 	}
@@ -134,70 +169,76 @@ func (c *Cluster) AddMachine(ctx context.Context, req *pb.AddMachineRequest) (*p
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "create IPAM manager: %v", err)
 	}
-	subnet, err := ipam.AllocateSubnetLen(network.DefaultSubnetBits)
+	subnet, err := ipam.AllocateSubnetLen(DefaultSubnetBits)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "allocate subnet for machine: %v", err)
 	}
-	m.Network.Subnet = pb.NewIPPrefix(subnet)
 
-	// TODO: announce the new machine to the cluster network using Serf and achieve consensus.
-	mCopy := proto.Clone(m).(*pb.MachineInfo)
-	c.state.State.Machines[mCopy.Id] = mCopy
-	// Store machine endpoints in a separate collection to allow modifying them with limited permissions.
-	c.state.State.Endpoints[mCopy.Id] = &pb.MachineEndpoints{
-		Id:        mCopy.Id,
-		Endpoints: req.Network.Endpoints,
+	m := &pb.MachineInfo{
+		Id:   mid,
+		Name: name,
+		Network: &pb.NetworkConfig{
+			Subnet:       pb.NewIPPrefix(subnet),
+			ManagementIp: manageIP,
+			Endpoints:    req.Network.Endpoints,
+			PublicKey:    req.Network.PublicKey,
+		},
+		PublicIp: req.PublicIp,
 	}
-	if err = c.state.Save(); err != nil {
-		return nil, status.Errorf(codes.Internal, "save state: %v", err)
+	// TODO: announce the new machine to the cluster members and achieve consensus.
+	//  We should perhaps not proceed if this machine is in a minority partition.
+	if err = c.store.CreateMachine(ctx, m); err != nil {
+		return nil, status.Errorf(codes.Internal, "create machine: %v", err)
 	}
-	slog.Info("Machine added to the cluster.", "id", m.Id, "name", m.Name)
-
-	// Include the machine endpoints in the response.
-	m.Network.Endpoints = req.Network.Endpoints
-
-	// TODO: notify all cluster machines about the new machine so they can update their peers config.
-	//  In PoC we just notify the local machine.
-	c.newMachinesCh <- m
+	slog.Info("Machine added to the cluster.",
+		"id", m.Id, "name", m.Name, "subnet", subnet, "public_key", secret.Secret(m.Network.PublicKey))
 
 	resp := &pb.AddMachineResponse{Machine: m}
 	return resp, nil
 }
 
+// ListMachines lists all machines in the cluster including their membership states.
 func (c *Cluster) ListMachines(ctx context.Context, _ *emptypb.Empty) (*pb.ListMachinesResponse, error) {
-	if c.state == nil {
-		return nil, status.Error(codes.FailedPrecondition, "cluster is not initialized")
-	}
-	// TODO: consider creating MachineInfo type that pb.MachineInfo is mapped to always carry valid data to reduce
-	//  error handling caused by conversions and nil pointers.
-	machines := make([]*pb.MachineInfo, 0, len(c.state.State.Machines))
-	for _, sm := range c.state.State.Machines {
-		m := proto.Clone(sm).(*pb.MachineInfo)
-		m.Network.Endpoints = c.state.State.Endpoints[m.Id].Endpoints
-		machines = append(machines, m)
-	}
-	return &pb.ListMachinesResponse{Machines: machines}, nil
-}
-
-func (c *Cluster) ListMachineEndpoints(
-	ctx context.Context, req *pb.ListMachineEndpointsRequest,
-) (*pb.ListMachineEndpointsResponse, error) {
-	if c.state == nil {
-		return nil, status.Error(codes.FailedPrecondition, "cluster is not initialized")
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
 	}
 
-	endpoints, ok := c.state.State.Endpoints[req.Id]
-	if !ok {
-		return nil, status.Errorf(codes.NotFound, "machine %q not found", req.Id)
+	machines, err := c.store.ListMachines(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
 	}
-	return &pb.ListMachineEndpointsResponse{Endpoints: endpoints}, nil
-}
 
-func (c *Cluster) AddUser(user *pb.User) error {
-	c.state.State.Users = append(c.state.State.Users, user)
-	return c.state.Save()
-}
+	states, err := c.corroAdmin.ClusterMembershipStates(true)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "get cluster membership states: %v", err)
+	}
 
-func (c *Cluster) ListUsers() []*pb.User {
-	return c.state.State.Users
+	members := make([]*pb.MachineMember, len(machines))
+	for i, m := range machines {
+		// If the machine is not in the cluster membership states or its state is not ALIVE or SUSPECT, it is DOWN.
+		// The exception is the current machine which is always UP as it is serving this request.
+		state := pb.MachineMember_DOWN
+		addr, _ := m.Network.ManagementIp.ToAddr()
+		for _, s := range states {
+			if s.Addr.Addr().Compare(addr) == 0 {
+				switch s.State {
+				case corrosion.MembershipStateAlive:
+					state = pb.MachineMember_UP
+				case corrosion.MembershipStateSuspect:
+					state = pb.MachineMember_SUSPECT
+				}
+				break
+			}
+		}
+		// If the machine is the current machine, it is UP.
+		if m.Id == c.machineID {
+			state = pb.MachineMember_UP
+		}
+		members[i] = &pb.MachineMember{
+			Machine: m,
+			State:   state,
+		}
+	}
+
+	return &pb.ListMachinesResponse{Machines: members}, nil
 }

internal/machine/cluster/dns.go

@@ -0,0 +1,159 @@
+package cluster
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"uncloud/internal/dns"
+	"uncloud/internal/machine/api/pb"
+	"uncloud/internal/machine/store"
+)
+
+// uncloudDNSKey is the key used to store the details of the reserved domain in the store.
+const uncloudDNSKey = "uncloud_dns"
+
+type uncloudDNSDomain struct {
+	// Endpoint is the API endpoint of the Uncloud DNS service where the domain is reserved.
+	Endpoint string
+	Name     string
+	// TODO: encrypt the token in the store.
+	Token string
+}
+
+func (c *Cluster) ReserveDomain(ctx context.Context, req *pb.ReserveDomainRequest) (*pb.Domain, error) {
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
+	}
+
+	if req.Endpoint == "" {
+		return nil, status.Error(codes.InvalidArgument, "API endpoint not set")
+	}
+
+	if _, err := c.storedDomain(ctx); err == nil {
+		return nil, status.Errorf(codes.AlreadyExists, "domain already reserved")
+	} else {
+		if s := status.Convert(err); s.Code() != codes.NotFound {
+			return nil, err
+		}
+	}
+
+	dnsClient := dns.NewClient()
+	name, token, err := dnsClient.ReserveDomain(req.Endpoint)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	domain := uncloudDNSDomain{
+		Endpoint: req.Endpoint,
+		Name:     name,
+		Token:    token,
+	}
+	domainJSON, err := json.Marshal(domain)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "marshal reserved domain for store: %v", err)
+	}
+	if err = c.store.Put(ctx, uncloudDNSKey, domainJSON); err != nil {
+		return nil, status.Errorf(codes.Internal, "store reserved domain: %v", err)
+	}
+
+	return &pb.Domain{Name: name}, nil
+}
+
+func (c *Cluster) GetDomain(ctx context.Context, _ *emptypb.Empty) (*pb.Domain, error) {
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
+	}
+
+	domain, err := c.storedDomain(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &pb.Domain{Name: domain.Name}, nil
+}
+
+func (c *Cluster) storedDomain(ctx context.Context) (uncloudDNSDomain, error) {
+	var domain uncloudDNSDomain
+	var domainJSON []byte
+
+	if err := c.store.Get(ctx, uncloudDNSKey, &domainJSON); err != nil {
+		if errors.Is(err, store.ErrKeyNotFound) {
+			return domain, status.Errorf(codes.NotFound, "domain not found")
+		}
+		return domain, status.Errorf(codes.Internal, "get domain from store: %v", err)
+	}
+
+	if err := json.Unmarshal(domainJSON, &domain); err != nil {
+		return domain, status.Errorf(codes.Internal, "unmarshal domain: %v", err)
+	}
+
+	return domain, nil
+}
+
+func (c *Cluster) ReleaseDomain(ctx context.Context, _ *emptypb.Empty) (*pb.Domain, error) {
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
+	}
+
+	domain, err := c.storedDomain(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = c.store.Delete(ctx, uncloudDNSKey); err != nil {
+		return nil, status.Errorf(codes.Internal, "delete domain from store: %v", err)
+	}
+	// TODO: implement and call Uncloud DNS endpoint to release/delete the domain.
+
+	return &pb.Domain{Name: domain.Name}, nil
+}
+
+func (c *Cluster) CreateDomainRecords(
+	ctx context.Context, req *pb.CreateDomainRecordsRequest,
+) (*pb.CreateDomainRecordsResponse, error) {
+	if err := c.checkInitialised(ctx); err != nil {
+		return nil, err
+	}
+
+	domain, err := c.storedDomain(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	dnsClient := dns.NewClient()
+	recordsReq := make([]dns.RecordRequest, len(req.Records))
+	for i, r := range req.Records {
+		recordsReq[i] = dns.RecordRequest{
+			Name:   r.Name,
+			Type:   dns.RecordType(r.Type.String()),
+			Values: r.Values,
+		}
+	}
+
+	recordsResp, err := dnsClient.CreateRecords(domain.Endpoint, domain.Name, domain.Token, recordsReq)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &pb.CreateDomainRecordsResponse{
+		Records: make([]*pb.DNSRecord, len(recordsResp)),
+	}
+	for i, r := range recordsResp {
+		resp.Records[i] = &pb.DNSRecord{
+			Name:   r.FQDN,
+			Values: r.Values,
+		}
+
+		switch r.Type {
+		case dns.RecordTypeA:
+			resp.Records[i].Type = pb.DNSRecord_A
+		case dns.RecordTypeAAAA:
+			resp.Records[i].Type = pb.DNSRecord_AAAA
+		}
+	}
+
+	return resp, nil
+}

internal/machine/cluster/ipam.go

@@ -7,6 +7,10 @@ import (
 	"net/netip"
 )
 
+const DefaultSubnetBits = 24
+
+var DefaultNetwork = netip.MustParsePrefix("10.210.0.0/16")
+
 // IPAM is an in-memory IP address manager for allocating and releasing subnets for machines from a cluster network.
 type IPAM struct {
 	network   netip.Prefix

internal/machine/cluster/machine.go

@@ -1,9 +1,7 @@
 package cluster
 
 import (
-	"crypto/rand"
 	"fmt"
-	"math/big"
 	"uncloud/internal/secret"
 )
 
@@ -14,14 +12,9 @@ func NewMachineID() (string, error) {
 
 // NewRandomMachineName generates a random machine name in the format "machine-xxxx".
 func NewRandomMachineName() (string, error) {
-	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
-	suffix := make([]byte, 4)
-	for i := range suffix {
-		randIdx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
-		if err != nil {
-			return "", fmt.Errorf("get random number: %w", err)
-		}
-		suffix[i] = charset[randIdx.Int64()]
+	suffix, err := secret.RandomAlphaNumeric(4)
+	if err != nil {
+		return "", fmt.Errorf("generate random suffix: %w", err)
 	}
-	return "machine-" + string(suffix), nil
+	return "machine-" + suffix, nil
 }

internal/machine/cluster/state.go

@@ -1,60 +0,0 @@
-package cluster
-
-import (
-	"fmt"
-	"google.golang.org/protobuf/proto"
-	"os"
-	"path/filepath"
-	"uncloud/internal/machine/api/pb"
-)
-
-const StateFile = "cluster.pb"
-
-type State struct {
-	State *pb.State
-	path  string
-}
-
-func StatePath(dataDir string) string {
-	return filepath.Join(dataDir, StateFile)
-}
-
-func NewState(path string) *State {
-	return &State{
-		State: &pb.State{
-			Machines:  make(map[string]*pb.MachineInfo),
-			Endpoints: make(map[string]*pb.MachineEndpoints),
-		},
-		path: path,
-	}
-}
-
-func (s *State) Load() error {
-	data, err := os.ReadFile(s.path)
-	if err != nil {
-		return fmt.Errorf("read state file %q: %w", s.path, err)
-	}
-	if err = proto.Unmarshal(data, s.State); err != nil {
-		return fmt.Errorf("parse state file %q: %w", s.path, err)
-	}
-	if s.State.Machines == nil {
-		s.State.Machines = make(map[string]*pb.MachineInfo)
-	}
-	if s.State.Endpoints == nil {
-		s.State.Endpoints = make(map[string]*pb.MachineEndpoints)
-	}
-	return nil
-}
-
-func (s *State) Save() error {
-	dir, _ := filepath.Split(s.path)
-	if err := os.MkdirAll(dir, 0700); err != nil {
-		return fmt.Errorf("create state directory %q: %w", dir, err)
-	}
-
-	data, err := proto.Marshal(s.State)
-	if err != nil {
-		return fmt.Errorf("marshal state: %w", err)
-	}
-	return os.WriteFile(s.path, data, 0600)
-}

internal/machine/corroservice/config.go

@@ -0,0 +1,80 @@
+package corroservice
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/BurntSushi/toml"
+	"net/netip"
+	"os"
+	"path/filepath"
+	"uncloud/internal/fs"
+)
+
+const (
+	DefaultUser       = "uncloud"
+	DefaultGossipPort = 51001
+	DefaultAPIPort    = 51002
+)
+
+// Config represents the Corrosion config.
+type Config struct {
+	DB     DBConfig     `toml:"db"`
+	Gossip GossipConfig `toml:"gossip"`
+	API    APIConfig    `toml:"api"`
+	Admin  AdminConfig  `toml:"admin"`
+}
+
+type DBConfig struct {
+	Path        string   `toml:"path"`
+	SchemaPaths []string `toml:"schema_paths"`
+}
+
+type GossipConfig struct {
+	Addr      netip.AddrPort `toml:"addr"`
+	Bootstrap []string       `toml:"bootstrap"`
+	Plaintext bool           `toml:"plaintext"`
+}
+
+type APIConfig struct {
+	Addr netip.AddrPort `toml:"addr"`
+}
+
+type AdminConfig struct {
+	Path string `toml:"path"`
+}
+
+func (c *Config) Write(path, owner string) error {
+	var data bytes.Buffer
+	encoder := toml.NewEncoder(&data)
+	encoder.Indent = "" // Disable indentation.
+	if err := encoder.Encode(c); err != nil {
+		return fmt.Errorf("encode config: %w", err)
+	}
+	if err := os.WriteFile(path, data.Bytes(), 0600); err != nil {
+		return err
+	}
+	if err := fs.Chown(path, owner, owner); err != nil {
+		return err
+	}
+	return nil
+}
+
+func MkDataDir(dir, owner string) error {
+	parent, _ := filepath.Split(dir)
+	// Use 0711 for parent directories to allow `owner` to access its nested data directory.
+	if err := os.MkdirAll(parent, 0711); err != nil {
+		return fmt.Errorf("create directory %q: %w", parent, err)
+	}
+	if err := os.Mkdir(dir, 0700); err != nil {
+		if !os.IsExist(err) {
+			return fmt.Errorf("create directory %q: %w", dir, err)
+		}
+	}
+
+	if owner != "" {
+		if err := fs.Chown(dir, owner, owner); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/machine/corroservice/docker.go

@@ -0,0 +1,129 @@
+package corroservice
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/image"
+	"github.com/docker/docker/api/types/mount"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
+	"io"
+	"log/slog"
+	"path/filepath"
+	"time"
+)
+
+const (
+	LatestImage = "ghcr.io/psviderski/corrosion:latest"
+)
+
+type DockerService struct {
+	Client  *client.Client
+	Image   string
+	Name    string
+	DataDir string
+	User    string
+}
+
+func NewDockerService(cli *client.Client, image, name, dataDir string) *DockerService {
+	return &DockerService{
+		Client:  cli,
+		Image:   image,
+		Name:    name,
+		DataDir: dataDir,
+	}
+}
+
+func (s *DockerService) Start(ctx context.Context) error {
+	_, err := s.Client.ContainerInspect(ctx, s.Name)
+	if err != nil {
+		if client.IsErrNotFound(err) {
+			return s.startNewContainer(ctx)
+		}
+		return fmt.Errorf("inspect container %q: %w", s.Name, err)
+	}
+	// TODO: recreate only if the container configuration has to be changed.
+	if err = s.Client.ContainerRemove(ctx, s.Name, container.RemoveOptions{Force: true}); err != nil {
+		return fmt.Errorf("remove container %q: %w", s.Name, err)
+	}
+
+	return s.startNewContainer(ctx)
+}
+
+func (s *DockerService) Restart(ctx context.Context) error {
+	if err := s.Client.ContainerRestart(ctx, s.Name, container.StopOptions{}); err != nil {
+		return fmt.Errorf("restart container %q: %w", s.Name, err)
+	}
+	return nil
+}
+
+func (s *DockerService) Running() bool {
+	c, err := s.Client.ContainerInspect(context.Background(), s.Name)
+	if err != nil {
+		return false
+	}
+
+	return c.State.Running
+}
+
+func (s *DockerService) containerConfig() *container.Config {
+	return &container.Config{
+		Image: s.Image,
+		Cmd:   []string{"corrosion", "agent", "-c", filepath.Join(s.DataDir, "config.toml")},
+		User:  s.User,
+	}
+}
+
+func (s *DockerService) hostConfig() *container.HostConfig {
+	return &container.HostConfig{
+		NetworkMode: network.NetworkHost,
+		RestartPolicy: container.RestartPolicy{
+			Name: container.RestartPolicyAlways,
+		},
+		Mounts: []mount.Mount{
+			// Bind mount the data directory at the same path inside the container to simplify path handling.
+			{
+				Type:   mount.TypeBind,
+				Source: s.DataDir,
+				Target: s.DataDir,
+			},
+		},
+	}
+}
+
+func (s *DockerService) startNewContainer(ctx context.Context) error {
+	_, err := s.Client.ContainerCreate(ctx, s.containerConfig(), s.hostConfig(), nil, nil, s.Name)
+	if err != nil {
+		if !client.IsErrNotFound(err) {
+			return fmt.Errorf("create container: %w", err)
+		}
+
+		slog.Info("Pulling Docker image for corrosion service.", "image", s.Image)
+		start := time.Now()
+
+		respBody, err := s.Client.ImagePull(ctx, s.Image, image.PullOptions{})
+		if err != nil {
+			return fmt.Errorf("pull image: %w", err)
+		}
+		defer respBody.Close()
+
+		// Wait for pull to complete.
+		if _, err := io.Copy(io.Discard, respBody); err != nil {
+			return fmt.Errorf("read pull response: %w", err)
+		}
+
+		slog.Info("Docker image pulled.", "image", s.Image, "duration", time.Since(start).String())
+
+		// Create container again after image pull.
+		if _, err = s.Client.ContainerCreate(ctx, s.containerConfig(), s.hostConfig(), nil, nil, s.Name); err != nil {
+			return fmt.Errorf("create container: %w", err)
+		}
+	}
+
+	if err = s.Client.ContainerStart(ctx, s.Name, container.StartOptions{}); err != nil {
+		return fmt.Errorf("start container: %w", err)
+	}
+
+	return nil
+}

internal/machine/corroservice/service.go

@@ -0,0 +1,9 @@
+package corroservice
+
+import "context"
+
+type Service interface {
+	Start(ctx context.Context) error
+	Restart(ctx context.Context) error
+	Running() bool
+}

internal/machine/corroservice/subprocess.go

@@ -0,0 +1,157 @@
+package corroservice
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log/slog"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"syscall"
+	"time"
+)
+
+const (
+	DefaultCommand = "corrosion"
+	DefaultDataDir = "/var/lib/uncloud/corrosion"
+)
+
+// SubprocessService implements the Service interface by running the service as a subprocess.
+type SubprocessService struct {
+	Command string
+	DataDir string
+
+	cmd         *exec.Cmd
+	running     bool
+	mu          sync.Mutex
+	cancelWatch context.CancelFunc
+}
+
+func DefaultSubprocessService() *SubprocessService {
+	return &SubprocessService{
+		Command: DefaultCommand,
+		DataDir: DefaultDataDir,
+	}
+}
+
+// TODO: maybe stop the process if this ctx is cancelled.
+func (s *SubprocessService) Start(ctx context.Context) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.running {
+		return nil
+	}
+	return s.startProcess(ctx)
+}
+
+func (s *SubprocessService) Restart(ctx context.Context) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.running {
+		if err := s.stopProcess(); err != nil {
+			return fmt.Errorf("stop process: %w", err)
+		}
+	}
+	return s.startProcess(ctx)
+}
+
+func (s *SubprocessService) Running() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.running
+}
+
+func (s *SubprocessService) startProcess(ctx context.Context) error {
+	s.cmd = exec.Command(s.Command, "agent", "-c", filepath.Join(s.DataDir, "config.toml"))
+
+	// Redirect stdout and stderr to the logger.
+	stdout, err := s.cmd.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("create stdout pipe: %w", err)
+	}
+	stderr, err := s.cmd.StderrPipe()
+	if err != nil {
+		return fmt.Errorf("create stderr pipe: %w", err)
+	}
+
+	go func() {
+		scanner := bufio.NewScanner(stdout)
+		for scanner.Scan() {
+			slog.Info("[corrosion]: " + scanner.Text())
+		}
+		// TODO: remove
+		slog.Info("######## corrosion redirect go routine end ########")
+	}()
+
+	go func() {
+		scanner := bufio.NewScanner(stderr)
+		for scanner.Scan() {
+			slog.Error("[corrosion]: " + scanner.Text())
+		}
+	}()
+
+	if err = s.cmd.Start(); err != nil {
+		return fmt.Errorf("start process: %w", err)
+	}
+	s.running = true
+
+	// Watch for process exit to update running status.
+	go func() {
+		if err := s.cmd.Wait(); err != nil {
+			slog.Error("corrosion process exited with error.", "code", s.cmd.ProcessState.ExitCode(), "err", err)
+		}
+
+		s.mu.Lock()
+		s.running = false
+		s.mu.Unlock()
+	}()
+
+	// TODO: figure out the waiting process
+	// Wait for initialization
+	//timer := time.NewTimer(2 * time.Second)
+	//defer timer.Stop()
+
+	//select {
+	////case <-timer.C:
+	////	s.running = true
+	////	return nil
+	//case <-watchCtx.Done():
+	//	return fmt.Errorf("process failed to start")
+	//case <-ctx.Done():
+	//	s.stopProcess()
+	//	return ctx.Err()
+	//}
+	return nil
+}
+
+func (s *SubprocessService) stopProcess() error {
+	if s.cmd == nil || s.cmd.Process == nil {
+		return nil
+	}
+
+	if err := s.cmd.Process.Signal(syscall.SIGTERM); err != nil {
+		return fmt.Errorf("send SIGTERM: %w", err)
+	}
+
+	// Wait up to 5 seconds for graceful shutdown before killing the process.
+	done := make(chan error, 1)
+	go func() {
+		done <- s.cmd.Wait()
+	}()
+
+	select {
+	case <-time.After(5 * time.Second):
+		if err := s.cmd.Process.Kill(); err != nil {
+			return fmt.Errorf("kill process: %w", err)
+		}
+	case err := <-done:
+		if err != nil {
+			return fmt.Errorf("process exited with error: %w", err)
+		}
+	}
+
+	return nil
+}

internal/machine/corroservice/systemd.go

@@ -0,0 +1,57 @@
+package corroservice
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os/exec"
+	"time"
+)
+
+const DefaultSystemdUnit = "uncloud-corrosion.service"
+
+type SystemdService struct {
+	DataDir string
+	Unit    string
+	running bool
+}
+
+func DefaultSystemdService(dataDir string) *SystemdService {
+	return &SystemdService{
+		DataDir: dataDir,
+		Unit:    DefaultSystemdUnit,
+	}
+}
+
+func (s *SystemdService) Start(ctx context.Context) error {
+	return s.startOrRestart(ctx, "start")
+}
+
+func (s *SystemdService) Restart(ctx context.Context) error {
+	return s.startOrRestart(ctx, "restart")
+}
+
+func (s *SystemdService) startOrRestart(ctx context.Context, cmd string) error {
+	if _, err := exec.Command("systemctl", cmd, s.Unit).Output(); err != nil {
+		return fmt.Errorf("systemctl %s %s: %w", cmd, s.Unit, err)
+	}
+	slog.Info(fmt.Sprintf("Corrosion systemd service %sed.", cmd), "unit", s.Unit)
+
+	// Optimistically wait for the corrosion service to start and initialise the database schema before proceeding.
+	timer := time.NewTimer(2 * time.Second)
+	defer timer.Stop()
+
+	select {
+	case <-timer.C:
+	case <-ctx.Done():
+		return nil
+	}
+
+	// TODO: run a goroutine to check the status of the service and log any errors in the uncloud log.
+	s.running = true
+	return nil
+}
+
+func (s *SystemdService) Running() bool {
+	return s.running
+}

internal/machine/docker/client.go

@@ -0,0 +1,239 @@
+package docker
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/errdefs"
+	"github.com/docker/docker/pkg/jsonmessage"
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"io"
+	"uncloud/internal/machine/api/pb"
+)
+
+// Client is a gRPC client for the Docker service that provides a similar interface to the Docker HTTP client.
+type Client struct {
+	conn       *grpc.ClientConn
+	grpcClient pb.DockerClient
+}
+
+// NewClient creates a new Docker gRPC client with the provided gRPC connection.
+func NewClient(conn *grpc.ClientConn) *Client {
+	return &Client{
+		conn:       conn,
+		grpcClient: pb.NewDockerClient(conn),
+	}
+}
+
+// Close closes the gRPC connection.
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
+
+// CreateContainer creates a new container based on the given configuration.
+func (c *Client) CreateContainer(
+	ctx context.Context,
+	config *container.Config,
+	hostConfig *container.HostConfig,
+	networkingConfig *network.NetworkingConfig,
+	platform *ocispec.Platform,
+	name string,
+) (container.CreateResponse, error) {
+	var resp container.CreateResponse
+	// Serialize configs to JSON.
+	configBytes, err := json.Marshal(config)
+	if err != nil {
+		return resp, fmt.Errorf("marshal container config: %w", err)
+	}
+	hostConfigBytes, err := json.Marshal(hostConfig)
+	if err != nil {
+		return resp, fmt.Errorf("marshal host config: %w", err)
+	}
+	networkingConfigBytes, err := json.Marshal(networkingConfig)
+	if err != nil {
+		return resp, fmt.Errorf("marshal networking config: %w", err)
+	}
+	platformBytes, err := json.Marshal(platform)
+	if err != nil {
+		return resp, fmt.Errorf("marshal platform: %w", err)
+	}
+
+	grpcResp, err := c.grpcClient.CreateContainer(ctx, &pb.CreateContainerRequest{
+		Config:        configBytes,
+		HostConfig:    hostConfigBytes,
+		NetworkConfig: networkingConfigBytes,
+		Platform:      platformBytes,
+		Name:          name,
+	})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return resp, errdefs.NotFound(err)
+			}
+		}
+		return resp, err
+	}
+
+	if err = json.Unmarshal(grpcResp.Response, &resp); err != nil {
+		return resp, fmt.Errorf("unmarshal gRPC response: %w", err)
+	}
+	return resp, nil
+}
+
+// InspectContainer returns the container information for the given container ID.
+func (c *Client) InspectContainer(ctx context.Context, id string) (types.ContainerJSON, error) {
+	var resp types.ContainerJSON
+
+	grpcResp, err := c.grpcClient.InspectContainer(ctx, &pb.InspectContainerRequest{Id: id})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return resp, errdefs.NotFound(err)
+			}
+		}
+		return resp, err
+	}
+
+	if err = json.Unmarshal(grpcResp.Response, &resp); err != nil {
+		return resp, fmt.Errorf("unmarshal gRPC response: %w", err)
+	}
+	return resp, nil
+}
+
+// StartContainer starts a container with the given ID and options.
+func (c *Client) StartContainer(ctx context.Context, id string, opts container.StartOptions) error {
+	optsBytes, err := json.Marshal(opts)
+	if err != nil {
+		return fmt.Errorf("marshal options: %w", err)
+	}
+
+	_, err = c.grpcClient.StartContainer(ctx, &pb.StartContainerRequest{
+		Id:      id,
+		Options: optsBytes,
+	})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return errdefs.NotFound(err)
+			}
+		}
+	}
+	return err
+}
+
+// StopContainer stops a container with the given ID and options.
+func (c *Client) StopContainer(ctx context.Context, id string, opts container.StopOptions) error {
+	optsBytes, err := json.Marshal(opts)
+	if err != nil {
+		return fmt.Errorf("marshal options: %w", err)
+	}
+
+	_, err = c.grpcClient.StopContainer(ctx, &pb.StopContainerRequest{
+		Id:      id,
+		Options: optsBytes,
+	})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return errdefs.NotFound(err)
+			}
+		}
+	}
+	return err
+}
+
+type MachineContainers struct {
+	Metadata   *pb.Metadata
+	Containers []types.ContainerJSON
+}
+
+func (c *Client) ListContainers(ctx context.Context, opts container.ListOptions) ([]MachineContainers, error) {
+	optsBytes, err := json.Marshal(opts)
+	if err != nil {
+		return nil, fmt.Errorf("marshal options: %w", err)
+	}
+
+	resp, err := c.grpcClient.ListContainers(ctx, &pb.ListContainersRequest{Options: optsBytes})
+	if err != nil {
+		return nil, err
+	}
+
+	machineContainers := make([]MachineContainers, len(resp.Messages))
+	for i, msg := range resp.Messages {
+		machineContainers[i].Metadata = msg.Metadata
+		if msg.Metadata != nil && msg.Metadata.Error != "" {
+			continue
+		}
+
+		if err = json.Unmarshal(msg.Containers, &machineContainers[i].Containers); err != nil {
+			return nil, fmt.Errorf("unmarshal containers: %w", err)
+		}
+	}
+
+	return machineContainers, nil
+}
+
+// RemoveContainer stops (kills after grace period) and removes a container with the given ID.
+func (c *Client) RemoveContainer(ctx context.Context, id string, opts container.RemoveOptions) error {
+	optsBytes, err := json.Marshal(opts)
+	if err != nil {
+		return fmt.Errorf("marshal options: %w", err)
+	}
+
+	_, err = c.grpcClient.RemoveContainer(ctx, &pb.RemoveContainerRequest{
+		Id:      id,
+		Options: optsBytes,
+	})
+	if err != nil {
+		if s, ok := status.FromError(err); ok {
+			if s.Code() == codes.NotFound {
+				return errdefs.NotFound(err)
+			}
+		}
+	}
+	return err
+}
+
+type PullImageMessage struct {
+	Message jsonmessage.JSONMessage
+	Err     error
+}
+
+func (c *Client) PullImage(ctx context.Context, image string) (<-chan PullImageMessage, error) {
+	stream, err := c.grpcClient.PullImage(ctx, &pb.PullImageRequest{Image: image})
+	if err != nil {
+		return nil, err
+	}
+
+	ch := make(chan PullImageMessage)
+
+	go func() {
+		defer close(ch)
+
+		for {
+			msg, err := stream.Recv()
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				ch <- PullImageMessage{Err: err}
+				return
+			}
+
+			var jm jsonmessage.JSONMessage
+			if err = json.Unmarshal(msg.Message, &jm); err != nil {
+				ch <- PullImageMessage{Err: fmt.Errorf("unmarshal JSON message: %w", err)}
+				return
+			}
+			ch <- PullImageMessage{Message: jm}
+		}
+	}()
+
+	return ch, nil
+}

internal/machine/docker/manager.go

@@ -0,0 +1,204 @@
+package docker
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	dockercontainer "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/events"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/client"
+	"log/slog"
+	"time"
+	"uncloud/internal/api"
+	"uncloud/internal/machine/store"
+)
+
+const (
+	NetworkName = "uncloud"
+	UserChain   = "DOCKER-USER"
+	// EventsDebounceInterval defines how long to wait before processing the next Docker event. Multiple events
+	// occurring within this window will be processed together as a single event to prevent system overload.
+	EventsDebounceInterval = 100 * time.Millisecond
+	// SyncInterval defines a regular interval to sync containers to the cluster store.
+	SyncInterval = 30 * time.Second
+)
+
+type Manager struct {
+	client *client.Client
+	// machineID is the ID of the machine where the managed Docker daemon is running.
+	machineID string
+	store     *store.Store
+}
+
+func NewManager(client *client.Client, machineID string, store *store.Store) *Manager {
+	return &Manager{
+		client:    client,
+		machineID: machineID,
+		store:     store,
+	}
+}
+
+// WaitDaemonReady waits for the Docker daemon to start and be ready to serve requests.
+func (m *Manager) WaitDaemonReady(ctx context.Context) error {
+	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
+
+	ready, waitingLogged := false, false
+	for !ready {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-ticker.C:
+			_, err := m.client.Ping(ctx)
+			if err == nil {
+				ready = true
+				break
+			}
+			if !client.IsErrConnectionFailed(err) {
+				return fmt.Errorf("connect to Docker daemon: %w", err)
+			}
+			if !waitingLogged {
+				slog.Info("Waiting for Docker daemon to start and be ready.")
+				waitingLogged = true
+			}
+		}
+	}
+	return nil
+}
+
+func (m *Manager) WatchAndSyncContainers(ctx context.Context) error {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	// Filter only local container events.
+	opts := events.ListOptions{
+		Filters: filters.NewArgs(
+			filters.Arg("scope", "local"),
+			filters.Arg("type", string(events.ContainerEventType)),
+		),
+	}
+
+	// Subscribe to Docker events before running the initial sync to avoid missing any events.
+	eventCh, errCh := m.client.Events(ctx, opts)
+	slog.Debug("Syncing containers to cluster store before processing Docker events.")
+	if err := m.syncContainersToStore(ctx); err != nil {
+		// The deferred cancel will stop the event subscription.
+		return fmt.Errorf("sync containers to cluster store: %w", err)
+	}
+
+	var (
+		// debouncer is used to debounce multiple Docker events into a single event sent to the debouncerCh
+		// to prevent system overload.
+		debouncer   *time.Timer
+		debouncerCh = make(chan events.Message)
+		// ticker is used to trigger a regular sync of containers to the cluster store as a fallback.
+		ticker = time.NewTicker(SyncInterval)
+	)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case e := <-eventCh:
+			switch e.Action {
+			// Actions that may trigger a container state change or creation/deletion of a container.
+			case events.ActionCreate,
+				events.ActionStart,
+				events.ActionStop,
+				events.ActionPause,
+				events.ActionUnPause,
+				events.ActionKill,
+				events.ActionDie,
+				events.ActionOOM,
+				events.ActionDestroy,
+				events.ActionHealthStatusHealthy,
+				events.ActionHealthStatusUnhealthy:
+
+				if debouncer == nil {
+					debouncer = time.AfterFunc(EventsDebounceInterval, func() {
+						debouncerCh <- e
+					})
+				}
+			}
+		case e := <-debouncerCh:
+			debouncer = nil
+			slog.Debug("Syncing containers to cluster store triggered by a Docker container event.",
+				"container_id", e.Actor.ID,
+				"container_name", e.Actor.Attributes["name"],
+				"action", e.Action)
+
+			if err := m.syncContainersToStore(ctx); err != nil {
+				return fmt.Errorf("sync containers to cluster store: %w", err)
+			}
+		case <-ticker.C:
+			slog.Debug("Syncing containers to cluster store triggered by a regular interval.",
+				"interval", SyncInterval)
+			if err := m.syncContainersToStore(ctx); err != nil {
+				return fmt.Errorf("sync containers to cluster store: %w", err)
+			}
+		case err := <-errCh:
+			if errors.Is(err, context.Canceled) {
+				return nil
+			}
+			return fmt.Errorf("receive Docker event: %w", err)
+		}
+	}
+}
+
+func (m *Manager) syncContainersToStore(ctx context.Context) error {
+	storeContainers, err := m.store.ListContainers(ctx, store.ListOptions{MachineIDs: []string{m.machineID}})
+	if err != nil {
+		return fmt.Errorf("list containers from store: %w", err)
+	}
+
+	// List only Uncloud service containers identified by their labels.
+	containerSummaries, err := m.client.ContainerList(ctx, dockercontainer.ListOptions{
+		Filters: filters.NewArgs(
+			filters.Arg("label", api.LabelServiceID),
+			filters.Arg("label", api.LabelServiceName),
+		),
+	})
+	if err != nil {
+		// TODO: mark all containers as outdated in the store.
+		return fmt.Errorf("list Docker containers: %w", err)
+	}
+
+	// Inspect each container to get the full container details.
+	containers := make([]api.Container, len(containerSummaries))
+	for i, cs := range containerSummaries {
+		ctr, err := m.client.ContainerInspect(ctx, cs.ID)
+		if err != nil {
+			return fmt.Errorf("inspect container '%s': %w", cs.ID, err)
+		}
+		containers[i] = api.Container{ContainerJSON: ctr}
+	}
+
+	// Delete containers from the store that are no longer present in the Docker daemon.
+	var deleteIDs []string
+	for _, sc := range storeContainers {
+		found := false
+		for i := range containers {
+			if containers[i].ID == sc.Container.ID {
+				found = true
+				break
+			}
+		}
+		if !found {
+			deleteIDs = append(deleteIDs, sc.Container.ID)
+		}
+	}
+
+	var storeErr error
+	if len(deleteIDs) > 0 {
+		if err = m.store.DeleteContainers(ctx, store.DeleteOptions{IDs: deleteIDs}); err != nil {
+			storeErr = fmt.Errorf("delete containers from store: %w", err)
+		}
+	}
+
+	// Create or update the current Docker containers in the store.
+	for _, c := range containers {
+		if err = m.store.CreateOrUpdateContainer(ctx, c, m.machineID); err != nil {
+			storeErr = errors.Join(storeErr, fmt.Errorf("create or update container %q: %w", c.ID, err))
+		}
+	}
+	return storeErr
+}

internal/machine/docker/manager_darwin.go

@@ -0,0 +1,14 @@
+//go:build darwin
+
+package docker
+
+import (
+	"context"
+	"fmt"
+	"net/netip"
+)
+
+// EnsureUncloudNetwork is a stub for darwin.
+func (m *Manager) EnsureUncloudNetwork(ctx context.Context, subnet netip.Prefix) error {
+	return fmt.Errorf("not supported on darwin")
+}

internal/machine/docker/manager_linux.go

@@ -0,0 +1,77 @@
+package docker
+
+import (
+	"context"
+	"fmt"
+	dnetwork "github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
+	"github.com/docker/docker/libnetwork/iptables"
+	"log/slog"
+	"net/netip"
+	"uncloud/internal/machine/network"
+)
+
+// EnsureUncloudNetwork creates the Docker bridge network NetworkName with the provided machine subnet
+// if it doesn't exist. If the network exists but has a different subnet, it removes and recreates the network.
+// It also configures iptables to allow container access from the WireGuard network.
+func (m *Manager) EnsureUncloudNetwork(ctx context.Context, subnet netip.Prefix) error {
+	// Ensure the Docker network 'uncloud' is created with the correct subnet.
+	needsCreation := false
+	nw, err := m.client.NetworkInspect(ctx, NetworkName, dnetwork.InspectOptions{})
+	if err != nil {
+		if !client.IsErrNotFound(err) {
+			return fmt.Errorf("inspect Docker network %q: %w", NetworkName, err)
+		}
+		needsCreation = true
+	} else if nw.IPAM.Config[0].Subnet != subnet.String() {
+		// Remove the Docker network if the subnet is different.
+		// It could be a leftover from a previous incomplete cleanup.
+		slog.Info(
+			"Removing Docker network with old subnet.", "name", NetworkName, "subnet", nw.IPAM.Config[0].Subnet,
+		)
+		if err = m.client.NetworkRemove(ctx, NetworkName); err != nil {
+			// It can still fail if the network is in use by a container. Leave it to the user to resolve the issue.
+			return fmt.Errorf("remove Docker network %q: %w", NetworkName, err)
+		}
+		needsCreation = true
+	}
+
+	if needsCreation {
+		if _, err = m.client.NetworkCreate(
+			ctx, NetworkName, dnetwork.CreateOptions{
+				Driver: "bridge",
+				Scope:  "local",
+				IPAM: &dnetwork.IPAM{
+					Config: []dnetwork.IPAMConfig{
+						{
+							Subnet: subnet.String(),
+						},
+					},
+				},
+			},
+		); err != nil {
+			return fmt.Errorf("create Docker network %q: %w", NetworkName, err)
+		}
+		slog.Info("Docker network created.", "name", NetworkName, "subnet", subnet.String())
+
+		if nw, err = m.client.NetworkInspect(ctx, NetworkName, dnetwork.InspectOptions{}); err != nil {
+			return fmt.Errorf("inspect Docker network %q: %w", NetworkName, err)
+		}
+	}
+
+	// Configure iptables to allow WireGuard network to access containers. The Docker daemon should have already
+	// created the DOCKER-USER chain at this point.
+	// TODO: check if this works when firewalld used instead of raw iptables. The Docker daemon has a different
+	//  code path for firewalld.
+
+	// Bridge name doesn't seem to be documented but this is the source code where it is generated:
+	// https://github.com/moby/moby/blob/v27.2.1/libnetwork/drivers/bridge/bridge_linux.go#L664
+	bridgeName := "br-" + nw.ID[:12]
+	ipt := iptables.GetIptable(iptables.IPv4)
+	rule := []string{"--in-interface", network.WireGuardInterfaceName, "--out-interface", bridgeName, "-j", "ACCEPT"}
+	if err = ipt.ProgramRule(iptables.Filter, UserChain, iptables.Insert, rule); err != nil {
+		return fmt.Errorf("insert iptables rule: %w", err)
+	}
+
+	return nil
+}

internal/machine/docker/server.go

@@ -0,0 +1,241 @@
+package docker
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/api/types/image"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
+	"io"
+	"uncloud/internal/machine/api/pb"
+)
+
+// Server implements the gRPC Docker service that proxies requests to the Docker daemon.
+type Server struct {
+	pb.UnimplementedDockerServer
+	client *client.Client
+}
+
+// NewServer creates a new Docker gRPC server with the provided Docker client.
+func NewServer(cli *client.Client) *Server {
+	return &Server{client: cli}
+}
+
+// CreateContainer creates a new container based on the given configuration.
+func (s *Server) CreateContainer(ctx context.Context, req *pb.CreateContainerRequest) (*pb.CreateContainerResponse, error) {
+	var config container.Config
+	var hostConfig container.HostConfig
+	var networkConfig network.NetworkingConfig
+	var platform ocispec.Platform
+
+	// Unmarshal configurations from the request.
+	if err := json.Unmarshal(req.Config, &config); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "unmarshal container config: %v", err)
+	}
+	if err := json.Unmarshal(req.HostConfig, &hostConfig); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "unmarshal host config: %v", err)
+	}
+	if err := json.Unmarshal(req.NetworkConfig, &networkConfig); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "unmarshal network config: %v", err)
+	}
+	if err := json.Unmarshal(req.Platform, &platform); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "unmarshal platform: %v", err)
+	}
+
+	resp, err := s.client.ContainerCreate(ctx, &config, &hostConfig, &networkConfig, &platform, req.Name)
+	if err != nil {
+		if client.IsErrNotFound(err) {
+			return nil, status.Errorf(codes.NotFound, err.Error())
+		}
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	respBytes, err := json.Marshal(resp)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "marshal response: %v", err)
+	}
+
+	return &pb.CreateContainerResponse{Response: respBytes}, nil
+}
+
+// InspectContainer returns the container information for the given container ID.
+func (s *Server) InspectContainer(ctx context.Context, req *pb.InspectContainerRequest) (*pb.InspectContainerResponse, error) {
+	resp, err := s.client.ContainerInspect(ctx, req.Id)
+	if err != nil {
+		if client.IsErrNotFound(err) {
+			return nil, status.Errorf(codes.NotFound, err.Error())
+		}
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	respBytes, err := json.Marshal(resp)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "marshal response: %v", err)
+	}
+
+	return &pb.InspectContainerResponse{Response: respBytes}, nil
+}
+
+// StartContainer starts a container with the given ID and options.
+func (s *Server) StartContainer(ctx context.Context, req *pb.StartContainerRequest) (*emptypb.Empty, error) {
+	var opts container.StartOptions
+	if len(req.Options) > 0 {
+		if err := json.Unmarshal(req.Options, &opts); err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "unmarshal options: %v", err)
+		}
+	}
+
+	if err := s.client.ContainerStart(ctx, req.Id, opts); err != nil {
+		if client.IsErrNotFound(err) {
+			return nil, status.Errorf(codes.NotFound, err.Error())
+		}
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	return &emptypb.Empty{}, nil
+}
+
+// StopContainer stops a container with the given ID and options.
+func (s *Server) StopContainer(ctx context.Context, req *pb.StopContainerRequest) (*emptypb.Empty, error) {
+	var opts container.StopOptions
+	if len(req.Options) > 0 {
+		if err := json.Unmarshal(req.Options, &opts); err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "unmarshal options: %v", err)
+		}
+	}
+
+	if err := s.client.ContainerStop(ctx, req.Id, opts); err != nil {
+		if client.IsErrNotFound(err) {
+			return nil, status.Errorf(codes.NotFound, err.Error())
+		}
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	return &emptypb.Empty{}, nil
+}
+
+func (s *Server) ListContainers(ctx context.Context, req *pb.ListContainersRequest) (*pb.ListContainersResponse, error) {
+	var opts container.ListOptions
+	if len(req.Options) > 0 {
+		if err := json.Unmarshal(req.Options, &opts); err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "unmarshal options: %v", err)
+		}
+
+		// Handle filters separately because they implement custom JSON unmarshalling.
+		var raw map[string]json.RawMessage
+		if err := json.Unmarshal(req.Options, &raw); err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "unmarshal options to raw map: %v", err)
+		}
+
+		if filtersBytes, ok := raw["Filters"]; ok {
+			args, err := filters.FromJSON(string(filtersBytes))
+			if err != nil {
+				return nil, status.Errorf(codes.InvalidArgument, "unmarshal filters: %v", err)
+			}
+			opts.Filters = args
+		}
+	}
+
+	containerSummaries, err := s.client.ContainerList(ctx, opts)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+	containers := make([]types.ContainerJSON, len(containerSummaries))
+	for i, cs := range containerSummaries {
+		c, err := s.client.ContainerInspect(ctx, cs.ID)
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "inspect container %s: %v", cs.ID, err)
+		}
+		containers[i] = c
+	}
+
+	containersBytes, err := json.Marshal(containers)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "marshal containers: %v", err)
+	}
+
+	return &pb.ListContainersResponse{
+		Messages: []*pb.MachineContainers{
+			{
+				Containers: containersBytes,
+			},
+		},
+	}, nil
+}
+
+// RemoveContainer stops (kills after grace period) and removes a container with the given ID.
+func (s *Server) RemoveContainer(ctx context.Context, req *pb.RemoveContainerRequest) (*emptypb.Empty, error) {
+	var opts container.RemoveOptions
+	if len(req.Options) > 0 {
+		if err := json.Unmarshal(req.Options, &opts); err != nil {
+			return nil, status.Errorf(codes.InvalidArgument, "unmarshal options: %v", err)
+		}
+	}
+
+	if err := s.client.ContainerRemove(ctx, req.Id, opts); err != nil {
+		if client.IsErrNotFound(err) {
+			return nil, status.Errorf(codes.NotFound, err.Error())
+		}
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	return &emptypb.Empty{}, nil
+}
+
+func (s *Server) PullImage(req *pb.PullImageRequest, stream grpc.ServerStreamingServer[pb.JSONMessage]) error {
+	ctx := stream.Context()
+
+	// TODO: replace with another JSON serializable type (PullOptions.PrivilegeFunc is not serializable).
+	var opts image.PullOptions
+	if len(req.Options) > 0 {
+		if err := json.Unmarshal(req.Options, &opts); err != nil {
+			return status.Errorf(codes.InvalidArgument, "unmarshal options: %v", err)
+		}
+	}
+
+	respBody, err := s.client.ImagePull(ctx, req.Image, opts)
+	if err != nil {
+		return status.Errorf(codes.Internal, err.Error())
+	}
+	defer respBody.Close()
+
+	decoder := json.NewDecoder(respBody)
+	errCh := make(chan error, 1)
+
+	go func() {
+		var raw json.RawMessage
+		for {
+			if err = decoder.Decode(&raw); err != nil {
+				if errors.Is(err, io.EOF) {
+					errCh <- nil
+					return
+				}
+				errCh <- status.Errorf(codes.Internal, "decode image pull message: %v", err)
+				return
+			}
+
+			if err = stream.Send(&pb.JSONMessage{Message: raw}); err != nil {
+				errCh <- status.Errorf(codes.Internal, "send image pull message to stream: %v", err)
+				return
+			}
+		}
+	}()
+
+	for {
+		select {
+		case err = <-errCh:
+			return err
+		case <-ctx.Done():
+			return status.Errorf(codes.Canceled, ctx.Err().Error())
+		}
+	}
+}