100 Days of Cloud: Day 3 - Dockerizing a Go App for Dita Daystar (Apologies for the Delay!)

Hey everyone,

I'm writing to apologize for the late submission for Day 3 of the 100 Days of Cloud challenge. I ran into some unexpected roadblocks, but I'm here now to conquer Docker and document the process for you all!

Today, we'll be diving into Docker and how to use it to containerize a Go application for our school club, Dita Daystar,my UNI.They have given me permission to document this whole process as a way to learn. Buckle up, and let's get started!

What is Docker and Why Do We Need It?

Imagine a world where your applications are self-contained packages that include everything they need to run – code, libraries, and configurations. That's the magic of Docker! Docker containers are like little virtual machines that isolate your application from the underlying system. This isolation ensures consistent behavior regardless of the environment, making your application more portable and reliable.

Here are some key benefits of using Docker:

Portability: Docker containers run consistently on any system with Docker installed, making your application deployment a breeze across different environments.
Isolation: Containers isolate applications from each other and the underlying system, preventing conflicts and ensuring a clean running environment.
Reproducibility: Once you define a Dockerfile (a recipe for building your container), you can be sure your application will run the same way everywhere.
Scalability: Spinning up new Docker containers is quick and easy, allowing you to scale your application up or down as needed.
Creating a Dockerfile: Step-by-Step

Now that we understand the power of Docker, let's see how to create a Dockerfile to containerize our Go application for Dita Daystar:

Base Image: We start by specifying the base image using the FROM instruction. In our case, we'll use the official golang:latest image, which provides a ready-made environment for building and running Go applications.

Copying Application Code: The COPY instruction is used to copy our application code from the current directory (".") to the /app/ directory within the container. This places our code in a designated location within the container filesystem.

Setting the Working Directory: We use the WORKDIR instruction to set the working directory for any subsequent commands within the Dockerfile. Here, we're setting it to /app/, which is where our application code resides.

Dependency Management: The RUN instruction allows us to execute commands within the container build process. We'll use this to run go mod tidy, which ensures our project has the necessary dependencies and cleans up any unused dependencies.

Defining the Command: Finally, the CMD instruction specifies the command that will be executed when the container starts. In our case, we're instructing the container to run our Go application using go run main.go. This will execute our main Go program upon container startup.

Here's the complete Dockerfile we've built:

Dockerfile
FROM golang:latest
COPY . /app/
WORKDIR /app
RUN go mod tidy
CMD ["go" "run" "cmd/main.go"]

Application Functionality (and Tomorrow's Debugging Challenge!)

Our Go application for Dita Daystar is ready to be containerized! However, there's a catch – it won't connect to a Postgres database yet. That's the challenge for tomorrow! We'll be debugging the connection issue and ensuring our application interacts seamlessly with Postgres within the container.

Possible Fixes for Connecting to Postgres:

There are a couple of reasons why your container might not be connecting to Postgres. Here are a few things to check:

Postgres Configuration: Ensure your Go application code has the correct connection details for your Postgres database. Double-check the host, port, username, and password within your code.
Network Connectivity: Verify that your container can reach the Postgres database. You might need to configure your Docker network to allow communication between the container and the Postgres instance.
Postgres Service: Make sure the Postgres service is running and accessible on the host machine where your Docker container is deployed.
By troubleshooting these potential issues, we should be able to get our Go application talking to Postgres within the container.

Let's try debugging the connection:

I was thinking I should double-check the connection details (host, port, username, password) in my Go application code to make sure they match my Postgres database configuration.
I could also try to ping the Postgres host from within the container to verify network connectivity.
Finally, I'll check if the Postgres service is up and running.