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

[nickhammond]

You should be able to add the registry as an accessory, then boot the registry via Kamal, update your configuration to point to your registry, and then do a deploy.

[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.

[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

[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.