{"id":5091,"date":"2020-10-24T23:07:40","date_gmt":"2020-10-24T22:07:40","guid":{"rendered":"https:\/\/rakhesh.com\/?p=5091"},"modified":"2020-10-25T11:22:14","modified_gmt":"2020-10-25T10:22:14","slug":"how-i-setup-gogs-docker-on-ports-80-and-22","status":"publish","type":"post","link":"https:\/\/rakhesh.com\/linux-bsd\/how-i-setup-gogs-docker-on-ports-80-and-22\/","title":{"rendered":"How I setup Gogs Docker on ports 80 and 22"},"content":{"rendered":"

This is just how I set it up Gogs<\/a> (running in Docker) at home to listen on ports 80 & 22 rather than the default 3000 & 22. I already had things setup a certain way so that’s why I did what I do below, so it might not suit everyone. (Note<\/strong>: there’s an update to this post since it was initially published).<\/p>\n

First off, thanks to the creators of Gogs. So nice being able to have a mini GitHub of your own at home. :) Prior to discovering Gogs I just had Git repos hosted on my Synology but I am spoilt with GitHub now so it was great to discover Gogs. There is a Gogs fork called Gitea<\/a> in case anyone’s intersted. Apparently it started because the Gogs developer went AWOL<\/a> and no one else had rights so it was forked. Lovely quote from the Gitea page, by Khalil Gibran:<\/p>\n

\n

Your children are not your children. They are the sons and daughters of Life\u2019s longing for itself. They come through you but not from you, and though they are with you yet they belong not to you.<\/p>\n<\/blockquote>\n

Anyhoo, moving to business.<\/p>\n

Here’s the official instructions<\/a> for setting up a Gogs container. I followed that.<\/p>\n

Within the container the Gogs config is at \/data\/gogs\/conf\/app.ini<\/code>, which if you followed the instructions actually resides on a volume you created and so is safe from any container deletions. This bit here is where you configure the HTTP and SSH ports:<\/p>\n

[server]\r\nDOMAIN           = gogs.rakhesh.home\r\nHTTP_PORT        = 3000\r\nEXTERNAL_URL     = http:\/\/gogs.rakhesh.home\/\r\nDISABLE_SSH      = false\r\nSSH_PORT         = 22\r\nSTART_SSH_SERVER = false\r\nOFFLINE_MODE     = false\r\n<\/pre>\n
I set the SSH port to 22 and that works fine. Now port 22 of the container will have SSH listening for requests. It’s a bit confusing that START_SSH_SERVER<\/code> is false<\/code> and I am talking about SSH running; that’s because Gogs has its own SSH server or it can make use of the OpenSSH server that’s very conveniently package in the container. The latter listens on port 22 and you can configure it via \/app\/gogs\/docker\/sshd_config<\/code> to change the port. I set the port to 22 in the ssh_config<\/code> file.<\/p>\n
My original plan was to run Gogs in a Macvlan network and so gogs.rakhesh.home<\/code> above was actually mapping to a LAN IP assigned to the container. That’s why I wanted both ports 22 and 80 to be mapped and work as usual because I wasn’t expecting any conflicts with the host ports 22 and 80. This plan changed later on, but I thought I’d mention it here for completeness.<\/p>\n
Initially I thought changing the HTTP port would be a simple case of changing the HTTP_PORT<\/code> above to 80. That didn’t work coz the process couldn’t bind to port 80. I thought that might be because of a lack of capabilities<\/a> so I tried running the container with the NET_BIND_SERVICE<\/code> capability but it didn’t help either. Then I realized that within the container the s6 process manager starts Gogs as a non-root user and obviously that can’t bind to port 80! I didn’t want to go down the route of changing it to be a root user so I went another way.<\/p>\n
At this point I decided to put Gogs behind my reverse proxy. I already had Caddy running on the host for other purposes so I assigned gogs.rakhesh.home<\/code> to the IP Caddy was listening on and added an entry like this in Caddyfile<\/code>:<\/p>\n
gogs.rakhesh.home:80 {\r\n        reverse_proxy http:\/\/127.0.0.1:3000\r\n}\r\n<\/pre>\n
Now any requests to port 80 of gogs.rakhesh.home<\/code> would be reverse proxied to Gogs listening on port 3000. Easy peasy.<\/p>\n
You’ll notice the IP I am reverse proxying to is a localhost one though. That’s because I decided to change things a bit. You see, reverse proxying port 80 via Caddy is fine but that now breaks SSH as the two are now listening on different IPs. If I go to gogs.rakhesh.home<\/code> port 80 I hit the Caddy IP and that’s fine, while if I go to port 22 I hit the host SSH server and not that of Gogs. So now I have a broken SSH!<\/p>\n
To workaround this I decided to use some iptables<\/code> port forwarding. But first since I don’t care about the container IP any more, I decided to map the localhost ports to the container ports so I can refer to them consistently (like in Caddy above and also in what I will do below). To that end here’s my Docker Compose file:<\/p>\n
version: \"3.8\"\r\n\r\nservices:\r\n    gogs:\r\n        image: gogs\/gogs-rpi:0.12\r\n        container_name: gogs\r\n        networks:\r\n            gogs_network:\r\n        ports:\r\n            - \"127.0.0.1:3000:3000\"\r\n            - \"127.0.0.1:3022:22\"\r\n        volumes:\r\n            - \"gogs_data:\/data\"\r\n            - \"gogs_backup:\/backup\"\r\n        environment:\r\n            - TZ=\"Europe\/London\"\r\n            - RUN_CROND=\"true\"\r\n            - BACKUP_INTERVAL=\"3h\"\r\n            - BACKUP_RETENTION=\"30d\"\r\n        restart: unless-stopped\r\n        logging:\r\n            # keep 3 log files, maximum size of 10m (default is unlimited)\r\n            options:\r\n                max-size: \"10m\"\r\n                max-file: \"3\"\r\n\r\nnetworks:\r\n    # a user defined bridge network for all my containers. create this externally so I can define the name, else docker-compose prefixes it with the project name. eugh!\r\n    gogs_network:\r\n      external: true\r\n      name: gogs_network\r\n\r\n# I specify the volume name again via \"name\" so that compose creates the volume with that name\r\n# If I don't do this the volume name before <projectname or foldername>-<the volume name below>.\r\nvolumes:\r\n    gogs_data:\r\n        name: gogs_data\r\n    gogs_backup:\r\n        name: gogs_backup\r\n<\/pre>\n
I went with Docker Compose for Gogs as that’s what I use nowadays. As I posted earlier<\/a> I realized Compose is super useful even for single containers as you can capture the config easily.<\/p>\n
So what am I doing above? I have a user-defined bridge network<\/a> called gogs_network<\/code> (that’s just best practice) (I create it beforehand though via docker network create gogs_network<\/code> as doing it via the compose file results in it adding a prefix, which I didn’t like). I attach the container to this network, it gets some IP, and I map ports 3000 and 3022 on 127.0.0.1 to ports 3000 and 22 inside the container. This way I can now have Caddy reverse proxy to 127.0.0.1:3000 and all I need is a way to port forward requests to my gogs.rakhesh.home<\/code> IPs port 22 (which is a different IP to my host) to forward to 127.0.0.1:3022. I can use iptables<\/code> for this:<\/p>\n
iptables -t nat -A PREROUTING -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 127.0.0.1:3022\r\niptables -t nat -A OUTPUT -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 127.0.0.1:3022<\/pre>\n
I need to modify the PREROUTING<\/code> chain for connections from other machines to the host. And I need to modify the OUTPUT<\/code> chain for when the host itself is trying to connect to Gogs. The rules are simple and similar; all they do is take any connections to port 22 of my gogs.rakhesh.home<\/code> IP and NAT it over to 127.0.0.1:3022.<\/p>\n
Because I am NATing to localhost I have to do the following in addition to the above rules:<\/p>\n
sysctl -w net.ipv4.conf.eth0.route_localnet=1<\/pre>\n
This tells<\/a> the kernel to allow routing to the 127\/8 subnet and has a security<\/a> implication. Since this is for my home environment and I don’t anything sensitive I am trying to hide via binding to localhost, I don’t mind the risk.<\/p>\n
Once this is in place I can now access gogs.rakhesh.home<\/code> on both port 80 and 22.<\/p>\n
Just to recap the Gogs config file, note that I am setting the HTTP port as 3000 and SSH port as 22, but I am setting the external URL without any port numbers (as that goes to Gogs).<\/p>\n
[server]\r\nDOMAIN           = gogs.rakhesh.home\r\nHTTP_PORT        = 3000\r\nEXTERNAL_URL     = http:\/\/gogs.rakhesh.home\/\r\nDISABLE_SSH      = false\r\nSSH_PORT         = 22\r\nSTART_SSH_SERVER = false\r\nOFFLINE_MODE     = false<\/pre>\n
You have to save the iptables<\/code> rules however you usually do them, and also add net.ipv4.conf.eth0.route_localnet=1<\/code> to \/etc\/sysctl.conf<\/code>. For my part I made a shell script with these (I added the sysctl<\/code> too here so I know they all go together)(iptables<\/code> rules get flushed each reboot so whenever I remove this service and reboot the rules will go away too):<\/p>\n
#!\/bin\/bash\r\n# Configure iptables firewall\r\n\r\n# Limit PATH\r\nPATH=\"\/sbin:\/usr\/sbin:\/bin:\/usr\/bin\"\r\n\r\niptables -t nat -A PREROUTING -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 127.0.0.1:3022\r\niptables -t nat -A OUTPUT -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 127.0.0.1:3022\r\n\r\nsysctl -w net.ipv4.conf.eth0.route_localnet=1<\/pre>\n
And made a systemd service file to run these at startup:<\/p>\n
[Unit]\r\nDescription=A service to make my changes to the iptables firewall\r\nAfter=network.target\r\n\r\n[Service]\r\nType=oneshot\r\nExecStart=\/opt\/iptables-firewall.sh\r\nRemainAfterExit=true\r\nRefuseManualStop=true\r\nStandardOutput=journal\r\n\r\n[Install]\r\nWantedBy=multi-user.target\r\n<\/pre>\n
That’s it!<\/p>\n
For what it’s worth I made a systemd service to start Gogs too automatically:<\/p>\n
[Unit]\r\nDescription=Gogs Container\r\nRequires=docker.service\r\nAfter=docker.service\r\n\r\n[Service]\r\nRestart=on-abort\r\nExecStart=\/usr\/bin\/docker start -a gogs\r\nExecStop=\/usr\/bin\/docker stop -t 2 gogs\r\n\r\n[Install]\r\nWantedBy=local.target<\/pre>\n
Hope that helps anyone!<\/p>\n
Update<\/h3>\n
I have since changed things a bit. Rather than exposing the 127\/8 network to the outside world I decided to forward to the bridged IP of the container itself.\u00a0<\/p>\n
Here’s my new Docker Compose file:<\/p>\n
ersion: \"3.8\"\r\n\r\nservices:\r\n    gogs:\r\n        image: gogs\/gogs-rpi:0.12\r\n        container_name: gogs\r\n        networks:\r\n            gogs_network:\r\n                ipv4_address: \"172.19.0.3\"\r\n        volumes:\r\n            - \"gogs_data:\/data\"\r\n            - \"gogs_backup:\/backup\"\r\n        environment:\r\n            - TZ=\"Europe\/London\"\r\n            - RUN_CROND=\"true\" \r\n            - BACKUP_INTERVAL=\"3h\"\r\n            - BACKUP_RETENTION=\"30d\"\r\n        restart: unless-stopped\r\n        logging:\r\n            # keep 3 log files, maximum size of 10m (default is unlimited)\r\n            options:\r\n                max-size: \"10m\"\r\n                max-file: \"3\"\r\n\r\nnetworks:\r\n    # a user defined bridge network for all my containers. create this externally so I can define the name, else docker-compose prefixes it with the project name. eugh!\r\n    gogs_network:\r\n      external: true\r\n      name: gogs_network\r\n\r\n# I specify the volume name again via \"name\" so that compose creates the volume with that name\r\n# If I don't do this the volume name before <projectname or foldername>-<the volume name below>.\r\nvolumes:\r\n    gogs_data:\r\n        name: gogs_data\r\n    gogs_backup:\r\n        name: gogs_backup\r\n<\/pre>\n
It’s similar to the old one except that 1) I don’t export any ports any more (as in I don’t map a port from the host IP to the container) and 2) I assign the container a static IP.<\/p>\n
With a static IP assigned I now point Caddy to that for port 80:<\/p>\n
gogs.rakhesh.home:80 {\r\n        reverse_proxy http:\/\/172.19.0.3:3000\r\n}<\/pre>\n
And now my firewall rules are the following:<\/p>\n
# a PREROUTING rule to catch packets incoming to the IP <ip of gogs>\r\n# this catches traffic from all other machines except this host itself\r\niptables -t nat -A PREROUTING -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n\r\n# an OUTPUT rule to catch packets that are going out of this host to the <ip of gogs> IP\r\n# this catches traffic from the host itself\r\niptables -t nat -A OUTPUT -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n\r\n# I have to add a filter table rule allowing port 22 to the container IP. Docker would typically do this if I had exposed the port.\r\n# I use the DOCKER-USER chain as that's left for user defined Docker rules.\r\niptables -t filter -I DOCKER-USER 1 -p tcp -d 172.19.0.3 --dport 22 -j ACCEPT<\/pre>\n
Again, mostly similar to what I was doing before except that 1) I now point to the container IP rather than the 127.0.0.1 local host IP & port and 2) I added a 3rd rule to allow traffic to the container. This way any traffic to the host’s IP I have kept aside for Gogs to be NAT’d to the internal IP for SSH.<\/p>\n
Notice I don’t have the sysctl<\/code> any more. Don’t need it.<\/p>\n
Lastly, I changed the shell script I had created for the firewall rules to also cleanup after itself:<\/p>\n
#!\/bin\/bash\r\n# Configure iptables firewall for Gogs\r\n\r\n# Limit PATH\r\nPATH=\"\/sbin:\/usr\/sbin:\/bin:\/usr\/bin\"\r\n\r\nstart() {\r\n        # a PREROUTING rule to catch packets incoming to the IP <ip of gogs>\r\n        # this catches traffic from all other machines except this host itself\r\n        iptables -t nat -A PREROUTING -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n\r\n        # an OUTPUT rule to catch packets that are going out of this host to the <ip of gogs> IP\r\n        # this catches traffic from the host itself\r\n        iptables -t nat -A OUTPUT -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n\r\n        # I have to add a filter table rule allowing port 22 to the container IP. Docker would typically do this if I had exposed the port.\r\n        # I use the DOCKER-USER chain as that's left for user defined Docker rules.\r\n        iptables -t filter -I DOCKER-USER 1 -p tcp -d 172.19.0.3 --dport 22 -j ACCEPT\r\n}\r\n\r\nstop() {\r\n        iptables -t nat -D PREROUTING -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n        iptables -t nat -D OUTPUT -p tcp -d <ip of gogs> --dport 22 -j DNAT --to-destination 172.19.0.3:22\r\n\r\n        iptables -t filter -D DOCKER-USER 1 \r\n}\r\n\r\n# execute action\r\ncase \"$1\" in\r\n        start)\r\n                echo \"Starting firewall\"\r\n                start\r\n                ;;\r\n        stop)\r\n                echo \"Stopping firewall\"\r\n                stop\r\n                ;;\r\nesac<\/pre>\n
(I changed the filename of the script as you’ll see in the unit file below). Finally, here’s the systemd unit file with a slight change to depend on the gogs.service<\/code>\u00a0and also incorporate the script changes above:<\/p>\n
[Unit]\r\nDescription=Firewall changes for Gogs Docker\r\nAfter=network.target gogs.service\r\nRequires=gogs.service\r\n\r\n[Service]\r\nType=oneshot\r\nExecStart=\/opt\/gogs-firewall.sh start\r\nExecStop=\/opt\/gogs-firewall.sh stop\r\nRemainAfterExit=true\r\nRefuseManualStop=false\r\nStandardOutput=journal\r\n\r\n[Install]\r\nWantedBy=multi-user.target<\/pre>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
This is just how I set it up Gogs (running in Docker) at home to listen on ports 80 & 22 rather than the default 3000 & 22. I already had things setup a certain way so that’s why I did what I do below, so it might not suit everyone. (Note: there’s an update … Continue reading How I setup Gogs Docker on ports 80 and 22<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false}}},"categories":[912,76],"tags":[936,103,935,556],"jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/posts\/5091"}],"collection":[{"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/comments?post=5091"}],"version-history":[{"count":0,"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/posts\/5091\/revisions"}],"wp:attachment":[{"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/media?parent=5091"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/categories?post=5091"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rakhesh.com\/wp-json\/wp\/v2\/tags?post=5091"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}