I have a few servers running some services using a custom domain I bought some time ago.
Each server has its own instance of caddy to handle a reverse proxy.
Only one of those servers can actually do the DNS challenge to generate the certificates, so I was manually copying the certificates to each other caddy instance that needed them and using the tls directive for that domain to read the files.
Just found there are two ways to automate this: shared storage, and on demand certificates.
So here's what I did to make it work with each one, hope someone finds it useful.
Shared storage
This one is in theory straight forward, you just mount a folder which all caddy instances will use.
I went through the route of using sshfs, so I created a user and added acls to allow the local caddy user and the new remote user to write the storage.
setfacl -Rdm u:caddy:rwx,d:u:caddy:rwX,o:--- ./
setfacl -Rdm u:remote_user:rwx,d:u:remote_user:rwX,o:--- ./
setfacl -Rm u:remote_user:rwx,d:u:remote_user:rwX,o:--- ./
Then on the server which will use the data I just mounted it
remote_user@<main_caddy_host>:/path/to/caddy/storage /path/to/local/storage fuse.sshfs noauto,x-systemd.automount,_netdev,reconnect,identityfile=/home/remote_user/.ssh/id_ed25519,allow_other,default_permissions,uid=caddy,gid=caddy 0 0
And included the mount as the caddy storage
{
storage file_system /path/to/local/storage
}
On demand
This one requires a separate service since caddy can't properly serve the file needed to the get_certificate directive
We could run a service which reads the key and crt files and combines them directly from the main caddy instance, but I went to serve the files and combine them in the server which needs them.
So, in my main caddy instance I have this:
I restrict the access by my tailscale IP, and include the /ask endpoint required by the on demand configuration.
@certificate host cert.localhost
handle @certificate {
@blocked not remote_ip <requester_ip>
respond @blocked "Denied" 403
@ask {
path /ask*
query domain=my.domain domain=jellyfin.my.domain
}
respond @ask "" 200
@askDenied `path('/ask*')`
respond @askDenied "" 404
root * /path/to/certs
@crt {
path /cert.crt
}
handle @crt {
rewrite * /wildcard_.my.domain.crt
file_server
}
@key {
path /cert.key
}
handle @key {
rewrite * /wildcard_.my.domain.key
file_server
}
}
Then on the server which will use the certs I run a service for caddy to make the http request.
This also includes another way to handle the /ask endpoint since wildcard certificates are not handled with *, caddy actually asks for each subdomain individually and the example above can't handle wildcard like domain=*.my.domain.
package main
import (
"io"
"net/http"
"strings"
"github.com/labstack/echo/v4"
)
func main() {
e := echo.New()
e.GET("/ask", func(c echo.Context) error {
if domain := c.QueryParam("domain"); strings.HasSuffix(domain, "my.domain") {
return c.String(http.StatusOK, domain)
}
return c.String(http.StatusNotFound, "")
})
e.GET("/cert.pem", func(c echo.Context) error {
crtResponse, err := http.Get("https://cert.localhost/cert.crt")
if err != nil {
return c.String(http.StatusInternalServerError, "")
}
crtBody, err := io.ReadAll(crtResponse.Body)
if err != nil {
return c.String(http.StatusInternalServerError, "")
}
defer crtResponse.Body.Close()
keyResponse, err := http.Get("https://cert.localhost/cert.key")
if err != nil {
return c.String(http.StatusInternalServerError, "")
}
keyBody, err := io.ReadAll(keyResponse.Body)
if err != nil {
return c.String(http.StatusInternalServerError, "")
}
return c.String(http.StatusOK, string(crtBody)+string(keyBody))
})
e.Logger.Fatal(e.Start(":1323"))
}
And in the CaddyFile request the certificate to this service
{
on_demand_tls {
ask http://localhost:1323/ask
}
}
*.my.domain {
tls {
get_certificate http http://localhost:1323/cert.pem
}
}
