Is it possible to deploy without a docker registry?

[Fire-Dragon-DoL]

I have a very fast internet connection (> 1Gbit) and the project I work on is very budget sensitive on the hosting side.
I don't have any need or reason to use a docker registry except that I need to get the docker image from my local machine to the remote machine.

After some research, it seems to be trivial to "push" a docker image over ssh:

docker save app:1.0 | gzip | DOCKER_HOST=ssh://user@remotehost docker load

(source)
This has a penalty on having to fully transfer the image, but to me uploading a 1GB image is ~8 seconds.

Is it possible to do something similar with Kamal?
The registry seems to be just a tax to move docker images from my local machine to a remote machine and the funny thing is that the registry is already a remote machine.

[yoelcabo]

Not sure if this is helpful, but another option is installing a docker registry in the machine you are deploying to:
https://distribution.github.io/distribution/

It surely adds some complexity though

[Fire-Dragon-DoL]

I see, thank you. I wish there is a way to do it without changing the config afterwards, but I can work around it with an environment variable.
Thank you!

[laptopmutia]

is there any real complexity for doing this?

or just some extra works to setup the distribution?

how is it going for you @Fire-Dragon-DoL have you done this?

I agree with u 1000% that the docker hub cost is really taxing

[Fire-Dragon-DoL]

I haven't, my existing setup is still working for now

[kjlape]

I have a simple docker registry deployed with kamal right now. It uses a hack to get bootstrapped because of the limitations we're discussing. If I could just deploy a public image (ala registry:2) using kamal, it'd be smooth sailing.

See example config here: https://gist.github.com/pingortle/040098454af630cc6cf6fa78bed9b018

Feel free to comment there. I may have made mistakes redacting from my production config.

[lpknv]

Not sure if this is helpful, but another option is installing a docker registry in the machine you are deploying to: https://distribution.github.io/distribution/

It surely adds some complexity though

I think a better way would be making the docker registry optional by default.

[motdotla]

This would be nice to have. This was my biggest surprise with Kamal. I was expecting its default to be sans-registry.

[Fire-Dragon-DoL]

That's what I imagined, or alternatively a hook for the "bootstrap" script to run more things.

[motdotla]

Would the docker load command avoid the need for a registry?

1. You can build a docker image to a tar.gz file with docker save your-image:latest | gzip > your-image-latest.tar.gz
2. And load it with docker load < your-image-latest.tar.gz
3. Then run it as usual with docker run

Could Kamal then theoretically push that tar.gz file up to your server on deploy, load it, and then run it?

edit: sorry, this is exactly what you described @Fire-Dragon-DoL. this feels like it should be the default - in the spirit of Kamal removing reliance on external services.

edit2:

Possibly:

1. make use of upload! source
2. add a push_gzip command that runs docker build && docker save | gzip > image.tar.gz and then upload!(image.tar.gz) source
3. add a load_gzip command that runs docker load < image.tar.gz source

[Fire-Dragon-DoL]

I have been doing that. It is quite slow, since images are usually big

[laptopmutia]

I think kamal should have things like this https://github.com/brthor/docker-push-ssh

[kjlape]

I like the idea of allowing docker load and also a way to deploy public images. If we had either of those options, it would simplify how I'm deploying my docker registry with kamal right now. https://gist.github.com/pingortle/040098454af630cc6cf6fa78bed9b018

[nickhammond]

Just to add to going the route of managing as an accessory with Kamal. The registry container is pretty flexible with how you want to host it and there's a bunch of documentation around it too. Kamal is great at booting up existing container images and managing the lifecycle of those.

https://distribution.github.io/distribution/about/deploying/
https://hub.docker.com/_/registry

You'd want to ensure authentication is in place and preferably it's firewalled appropriately as well, something like this though with the additional ENV options in place for auth.

accessories:
  registry:
    image: registry
    host: server-ip
    port: 5000

[laptopmutia]

can you elaborate more on that?
reading more here run-an-externally-accessible-registry

I need to atleast make TLS to avoid MITM,
the needs to have TLS before the apps even running feels so wrong, if I only use 1 server and without domain

seems there is no simple way to do this currently

to me I think we need to push the image with ssh

[waynehoover]

There is a nice blog post about how to host your own registry here https://nochlin.com/blog/host-your-own-docker-registry-with-kamal-2?utm_source=shortruby&ref=shortruby.com

[doroved]

We have to get rid of the Docker Registry

[Fire-Dragon-DoL]

My idea for now is to temporarily run the registry on the machine running kamal (yes it needs a tunnel of some sort), take it down when the deployment is done

[kjlape]

The approach in the blog post there is pretty slick!

If you want to further separate out your docker registry into its own kamal config so you can share it across projects, here's a quick example of what I'm experimenting with now. https://gist.github.com/pingortle/040098454af630cc6cf6fa78bed9b018

[driveton]

@kjlape the gist is gone, can you re-share? The Blog post to use own registry works. I'm glad I don't need to deal with docker or AWS anymore for my projects.

[kjlape]

@kjlape the gist is gone, can you re-share? The Blog post to use own registry works. I'm glad I don't need to deal with docker or AWS anymore for my projects.

@driveton Sure! Here's the correct link to the gist: https://gist.github.com/kjlape/040098454af630cc6cf6fa78bed9b018

[hrstoyanov]

During the RR2024 event in October 2024, @djmb mentioned it was coming. Any ETA? ... Hate the registries

[t3ndai]

yeah, it will be nice if the registry option can omitted completely e.g bundling the docker image into a tar file then using rsync to upstream to the server and rebuilding the image on the server. only question is how long that would take. at the moment -- I use rsync for my deploys.

[fnordfish]

I've stumbled upon this thread while looking into Kamal to replace/unify my current shell script deployments. I have some very simple dockered apps that run on single machines. Those machines do not have access to the repository or its registry.

Just as food for thought, here is what I do:

• SSH forwarding the remote docker socket to a local port (-L localhost:12345:/var/run/docker.sock)
• temporary configure local docker to use the forwarded port as docker host (export DOCKER_HOST="localhost:12345")
• Build and tag the image using a generated name.
• Write the tag name into a "current_tag" file
• Restart the service. Which will docker run the image read from the "current_tag" file.

As usual, there are quite some tradeoffs. Most of them check into the "pro" column for me:

• No registry to setup/maintain.
• No hassle with architecture differences.
• Kind to local bandwidth, only pushes build context to the target host.
• Makes use of target resources like bandwidth, CPU, image caches.

[tannakartikey]

The Kamal team is working towards this. I have noticed them mention this a few times.

Here's the branch I found if you want to see in which direction it's going.
https://github.com/basecamp/kamal/tree/local-docker-registry

It's not official so treat it accordingly.

[psviderski]

I build https://github.com/psviderski/unregistry to push Docker images directly to remote servers without an external registry. It transfers only the missing layers, making it fast and efficient.

The Kamal team may consider integrating it as an option to bypass the registry requirements if they like. cc @dhh

[Fire-Dragon-DoL]

I tested unregistry and it was flawless. I'm hoping for an integration with Kamal!

[schrockwell]

I really like the idea of this, but it falls down when the architecture of your local environment doesn't match the server (e.g. arm64 vs amd64).

[psviderski]

It definitely doesn't work automagically because you have to explicitly tell docker when you want to build a multi-platform image or use a specific platform.

In the usage docs for unregistry I just suggest using containerd image store locally to make it easy to build and manage multi-platform images:

Push a specific platform for a multi-platform image. The local Docker has to use containerd image store to support multi-platform images.

docker pussh myapp:latest user@server --platform linux/amd64

Locally (macOS arm64) I usually build a multi-arch image the following way:

docker build --platform=linux/amd64,linux/arm64 -t IMAGE .

Then I can run in both locally and remotely regardless whether the host is arm64 or amd64.

[yokonao]

I'd like to share a workaround I've developed for deploying without relying on external registries (Docker Hub, AWS ECR, GitHub Container Registry, etc.).

My approach involves running a local registry server and using it to transfer images to the remote server.
The registry server uses the official registry image.
For this example, I'll assume the registry server runs on localhost:50000 (any consistent port number works).

First, configure the Kamal deployment file (config/deploy.yml):

# Credentials for your image host.
registry:
  server: localhost:50000
  username: dummy
  password: dummy

The key points are specifying localhost as the registry server and using dummy values for username and password.

Next, start the registry server:

docker run -d -p "localhost:50000:5000" --name kamal-local-registry-server \
    -v "kamal-local-registry-server-data:/var/lib/registry" \
    registry:3

Then set up SSH port forwarding to tunnel the remote machine's port 50000 to the local machine's port 50000:

ssh -N -R "50000:localhost:50000" user@host

Finally, just run bin/kamal deploy!

This entire process can be wrapped into a shell script. I can also share the script I'm using if you'd like a reference implementation.

bin/deploy

#!/bin/bash

set -euo pipefail

IMAGE_NAME="$(yq .image <config/deploy.yml)"
COMMIT_HASH="$(git rev-parse HEAD)"
LOCAL_REGISTRY_SERVER_NAME="kamal-local-registry-server"
LOCAL_REGISTRY_SERVER_PORT=50000
LOCAL_REGISTRY_SERVER_URL="localhost:${LOCAL_REGISTRY_SERVER_PORT}"
SSH_FORWARDER_PIDS=()
SSH_REMOTE_SERVERS=()
SSH_USER="$(yq '.ssh.user // "root"' <config/deploy.yml)"

while read -r server; do
    SSH_REMOTE_SERVERS+=("$server")
done < <(yq '.servers.web[]' < config/deploy.yml)

cleanup() {
    echo "Cleaning up..."

    if docker ps -q -f name="$LOCAL_REGISTRY_SERVER_NAME" | grep -q .; then
        echo "Stopping and removing docker container: $LOCAL_REGISTRY_SERVER_NAME"
        docker rm -f "$LOCAL_REGISTRY_SERVER_NAME"
    fi

    for pid in "${SSH_FORWARDER_PIDS[@]}"; do
        if kill -0 "$pid" 2>/dev/null; then
            echo "Killing SSH forwarder process: $pid"
            kill "$pid"
        fi
    done
}

trap cleanup EXIT INT TERM

# launch local registry server
echo "Launching local registry server..."
docker run -d -p "$LOCAL_REGISTRY_SERVER_PORT:5000" --name $LOCAL_REGISTRY_SERVER_NAME \
    -v "${LOCAL_REGISTRY_SERVER_NAME}-data:/var/lib/registry" \
    registry:3

# allowing remote servers to access the local registry server
for server in "${SSH_REMOTE_SERVERS[@]}"; do
    ssh -N -R "$LOCAL_REGISTRY_SERVER_PORT:$LOCAL_REGISTRY_SERVER_URL" "${SSH_USER}@${server}" &
    SSH_FORWARDER_PIDS+=($!)
done

# 1. build image and push it to the local registry server
# 2. pull image on the remote server
# 3. rollout docker container
bin/kamal deploy

[gregjotau]

Ref.

https://github.com/basecamp/kamal/releases/tag/v2.8.0

Use local docker registry to push and pull app images by @npezza93 in #1355

I guess that is the closest way to achieve this, by simply running a local registry (either on your own machine or on the CI server)

GPT says I can do something like this:

# create persistent storage
sudo mkdir -p /var/lib/registry
sudo chown 1000:1000 /var/lib/registry

# run registry on 127.0.0.1:5000 (HTTP, loopback only)
sudo docker run -d --name registry \
  -p 127.0.0.1:5000:5000 \
  -v /var/lib/registry:/var/lib/registry \
  -e REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/var/lib/registry \
  registry:2

But not sure if someone has guides/tips to do this if we have an Ubuntu 24 CI server for example (where we run kamal deploy from)

[bradleymarques]

This is now possible with: https://kamal-deploy.org/docs/configuration/docker-registry/#using-a-local-container-registry

If using Rails 8.1.1 or higher:

1. Simply change the deploy.yml registry to be a localhost address as per the above link
2. Run kamal registry setup. This will create a local Docker container that is a docker repository
3. Run kamal deploy as before.

[Fire-Dragon-DoL]

Thank you, this is amazing!

[schrockwell]

Fantastic, thank you so much. This makes Kamal SO much better for a solo dev with a bunch of little side projects - now I don't need to pay for a private registry.

[indigotechtutorials]

Finally 🙏🎉