How to Deploy a Go Web Application on Ubuntu

Introduction

In the modern software development landscape, deploying applications efficiently is crucial. This tutorial will guide you through deploying a Go web application using Docker and Nginx on Ubuntu 22.04. Utilizing Docker allows for easy packaging of applications along with their dependencies, ensuring consistency across different environments. Nginx serves as a reverse proxy for enhanced performance, security, and configurability.

Prerequisites

• Basic understanding of Docker and its functionalities.
• A registered domain name pointing to your server’s public IP address.
• Docker and Docker Compose installed on your Ubuntu 22.04 server.
• Access to an Ubuntu 22.04 server with root privileges and a non-root user.

Step 1: Creating an Example Go Web Application

The first step involves setting up your workspace and creating a simple Go web application. This application will utilize the gorilla/mux router for handling requests. Follow these commands to create your workspace:

mkdir ~/go-docker
cd ~/go-docker

Next, create a new Go file named main.go:

nano main.go

Insert the following code into main.go:

package main

import (
"fmt"
"net/http"

"github.com/gorilla/mux"
)

func main() {
r := mux.NewRouter()
r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "
This is the homepage. Try /hello and /hello/Sammy
")

})
r.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "
Hello!
")

})
r.HandleFunc("/hello/{name}", func(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
name := vars["name"]
fmt.Fprintf(w, "
Hello, %s!
", name)

})
http.ListenAndServe(":8080", r)
}

Step 2: Containerizing the Go Application

Now that you created your Go application, the next step is to containerize it using Docker. Begin by creating a Dockerfile within the same directory:

nano Dockerfile

Add the following lines to the Dockerfile:

FROM golang:1.20-alpine AS builder

WORKDIR /app
COPY . .

RUN go build -o main .

FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/main .

CMD ["./main"]

Step 3: Creating a Docker Compose File

Next, create a docker-compose.yml file to define the services required for your application. Create the file by running:

nano docker-compose.yml

Inside the file, add the following configuration:

version: '3'

services:
web:
build: .
ports:
"8080:8080"
networks:
app-network

nginx:
image: nginx:latest
ports:
"80:80"
volumes:
./nginx.conf:/etc/nginx/conf.d/default.conf
networks:
app-network

networks:
app-network:

Step 4: Configuring Nginx

Next, you need to configure Nginx to serve as a reverse proxy for your Go application. Create a new file called nginx.conf:

nano nginx.conf

Add the following configuration to the nginx.conf file:

server {
listen 80;

location / {
proxy_pass http://web:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}

Step 5: Running the Application

Before running your application, ensure that Docker and Docker Compose are running properly. Use the following command to start your application:

docker-compose up --build

You should see output indicating that the Go application and Nginx server are up and running. You can access your application by navigating to http://your_domain in your browser.

Advanced Configuration

For production environments, it’s essential to secure your application with HTTPS. You can use Let’s Encrypt to obtain free SSL/TLS certificates. Consider using the nginx-proxy and its companion letsencrypt-nginx-proxy-companion images for automatic certificate generation and renewal.

To set this up, add the following services to your docker-compose.yml:

  nginx-proxy:
image: jwilder/nginx-proxy
ports:
"80:80"
"443:443"
volumes:
/var/run/docker.sock:/tmp/docker.sock:ro

letsencrypt-nginx-proxy-companion:
image: jrcs/letsencrypt-nginx-proxy-companion
volumes:
/var/run/docker.sock:/var/run/docker.sock:ro
environment:
NGINX_PROXY_CONTAINER=nginx-proxy
ACME_EMAIL=you@example.com
ACME_DOMAINS=your_domain

Best Practices

• Regularly update your Docker images to incorporate security patches and improvements.
• Utilize environment variables to manage configuration settings securely.
• Implement logging and monitoring for performance insights and debugging.
• Regularly back up your application data and configurations.

Troubleshooting

If you encounter issues during deployment, consider the following troubleshooting tips:

• Check Docker logs using docker-compose logs for any error messages.
• Ensure all dependencies are correctly installed and configured.
• Verify that your domain's A record correctly points to your server's IP.
• Test the Nginx configuration with nginx -t to check for syntax errors.

Conclusion

Congratulations! You have successfully deployed a Go web application on Ubuntu using Docker and Nginx. By utilizing Docker, you've containerized your application, which simplifies deployment and scaling. Nginx serves as a robust reverse proxy, handling incoming requests efficiently. Always remember to follow best practices for security and performance when deploying applications.

For further assistance or consultation on deploying web applications, feel free to reach out!

Konsultasi Jasa Setup Sekarang

This HTML document serves as a comprehensive guide for deploying a Go web application on Ubuntu, covering the necessary steps, configuration, best practices, and troubleshooting. Please replace your_domain with your actual domain name and adjust the instructions according to your specific needs.