docs: add images and enhance documentation for Golang application monitoring with Prometheus and Grafana

Author: Pradumnasaraf

content/guides/go-prometheus-monitoring/_index.md

@@ -10,29 +10,31 @@ params:
   time: 45 minutes
 ---
 
-The guide teaches you how to containerize a Golang application and monitor it with Prometheus and Grafana. In this guide, you'll learn how to:
+The guide teaches you how to containerize a Golang application and monitor it with Prometheus and Grafana. 
 
 > **Acknowledgment**
 >
 > Docker would like to thank [Pradumna Saraf](https://twitter.com/pradumna_saraf) for his contribution to this guide.
 
 ## Overview
 
-To make sure our application is working as intended, monitoring is really important. In this guide, you'll learn how to containerize a Golang application and monitor it with Prometheus and Grafana.
+To make sure our application is working as intended, monitoring is really important. One of the most popular monitoring tools is Prometheus. Prometheus is an open-source monitoring and alerting toolkit that is designed for reliability and scalability. It collects metrics from monitored targets by scraping metrics HTTP endpoints on these targets. To visualize the metrics, we can use Grafana. Grafana is an open-source platform for monitoring and observability that allows you to query, visualize, alert on, and understand your metrics no matter where they are stored.
 
-We will create a Golang server with some endpoints to simulate a real-world application. Then we will expose metrics from the server using Prometheus. Finally, we will visualize the metrics using Grafana. We will containerize the Golang application and using the Docker Compose file, we will connect all the services- Golang, Prometheus, and Grafana.
+In this guide, we will be creating a Golang server with some endpoints to simulate a real-world application. Then we will expose metrics from the server using Prometheus. Finally, we will visualize the metrics using Grafana. We will containerize the Golang application and using the Docker Compose file, we will connect all the services- Golang, Prometheus, and Grafana. 
 
 ## What will you learn?
 
-* Create a Golang application with Prometheus metrics.
+* Create a Golang application with custom Prometheus metrics.
 * Containerize a Golang application.
 * Use Docker Compose to run multiple services and connect them together to monitor a Golang application with Prometheus and Grafana.
-* Visualize the metrics using Grafana.
+* Visualize the metrics using Grafana dashboards.
 
 ## Prerequisites
 
 - A good understanding of Golang is assumed.
-- You must me familiar with Prometheus and Grafana concepts. If you are new to Prometheus and Grafana.
+- You must me familiar with Prometheus and creating dashboards in Grafana.
 - You must have familiarity with Docker concepts like containers, images, and Dockerfiles. If you are new to Docker, you can start with the [Docker basics](/get-started/docker-concepts/the-basics/what-is-a-container.md) guide.
 
-Start by containerizing an existing Bun application.
+## Next steps
+
+We will be creating a Golang server and exposing metrics using Prometheus.

content/guides/go-prometheus-monitoring/application.md

@@ -12,9 +12,7 @@ aliases:
 
 * You have a [Git client](https://git-scm.com/downloads). The examples in this section use a command-line based Git client, but you can use any client.
 
-## Overview
-
-To make sure our application is working an intended, monitoring is really important. In this guide, you'll learn how to containerize a Golang application and monitor it with Prometheus and Grafana. In this guide, you'll learn how to:
+We will be creating a Golang server with some endpoints to simulate a real-world application. Then we will expose metrics from the server using Prometheus.
 
 ## Getting the sample application
 
@@ -34,6 +32,7 @@ go-prometheus-monitoring
 ├── Docker
 │   ├── grafana.yml
 │   └── prometheus.yml
+├── dashboard.json
 ├── Dockerfile
 ├── LICENSE
 ├── README.md
@@ -43,6 +42,16 @@ go-prometheus-monitoring
 └── main.go
 ```
 
+- **main.go** - The entry point of the application.
+- **go.mod and go.sum** - Go module files.
+- **Dockerfile** - Dockerfile used to build the app.
+- **Docker/** - Contains the Docker Compose configuration files for Grafana and Prometheus.
+- **compose.yaml** - Compose file to launch everything (Golang app, Prometheus, and Grafana).
+- **dashboard.json** - Grafana dashboard configuration file.
+- **Dockerfile** - Dockerfile used to build the Golang app.
+- **compose.yaml** - Docker Compose file to launch everything (Golang app, Prometheus, and Grafana).
+- Other files are for licensing and documentation purposes.
+
 ## Understanding the application
 
 Below is complete logic of the application you will find in the `main.go`. Let's break this to understand code better.
@@ -217,7 +226,7 @@ Make sure you are still inside `go-prometheus-monitoring` directory in the termi
 Now let's check our application's metrics by accessing the `/metrics` endpoint. 
 Open `http://localhost:8000/metrics` in your browser. You should see similar output to the one below.
 
-```text
+```sh
 # HELP api_http_request_error_total Total number of errors returned by the API
 # TYPE api_http_request_error_total counter
 api_http_request_error_total{path="/",status="404"} 1
@@ -229,11 +238,10 @@ api_http_request_total{path="/health",status="200"} 2
 api_http_request_total{path="/v1/users",status="200"} 1
 ```
 
-In the terminal, press `ctrl`+`c` to stop the application.
+In the terminal, press `ctrl` + `c` to stop the application.
 
-:::note
-If you don't want to run the application locally, and want to run it in a Docker container, skip to next page where we create a Dockerfile and containerize the application.
-:::
+> [!Note]
+> If you don't want to run the application locally, and want to run it in a Docker container, skip to next page where we create a Dockerfile and containerize the application.
 
 ## Summary
 

content/guides/go-prometheus-monitoring/compose.md

@@ -151,4 +151,17 @@ The services will start running, and you can access the Golang application at `h
 $ docker ps
 ```
 
-Next, we will learn how to develop the Golang application with Docker Compose and monitor it with Prometheus and Grafana.
+## Summary
+
+In this section, you learned how to connect services together using Docker Compose. You created a Docker Compose file to run multiple services together and connect them using networks. You also learned how to build and run the services using Docker Compose.
+
+Related information:
+
+ - [Docker Compose overview](/manuals/compose/_index.md)
+ - [Compose file reference](/reference/compose-file/_index.md)
+
+Next, we will learn how to develop the Golang application with Docker Compose and monitor it with Prometheus and Grafana.
+
+## Next steps
+
+In the next section, you will learn how to develop the Golang application with Docker. You will also learn how to use Docker Compose Watch to rebuild the image whenever you make changes to the code. Lastly, you will test the application and visualize the metrics in Grafana using Prometheus as the datasource.

content/guides/go-prometheus-monitoring/containerize.md

@@ -8,6 +8,8 @@ aliases:
   - /guides/go-prometheus-monitoring/containerize/
 ---
 
+Containerization helps us bundle the application and its dependencies into a single package called a container. This package can run on any platform without worrying about the environment. In this section, we will learn how to containerize a Golang application using Docker.
+
 To containerize a Golang application, we first need to create a Dockerfile. The Dockerfile contains instructions to build and run the application in a container. Also, when creating a Dockerfile, we can follow different sets of best practices to optimize the image size and make it more secure.
 
 ## Creating a Dockerfile
@@ -59,13 +61,13 @@ The Dockerfile consists of two stages:
 
 1. **Build stage**: This stage uses the official Golang image as the base and sets the necessary environment variables. It also sets the working directory inside the container, copies the `go.mod` and `go.sum` files for dependency installation, downloads the dependencies, copies the entire application source, and builds the Go binary.
 
-We use the `golang:1.24-alpine` image as the base image for the build stage. The `CGO_ENABLED=0` environment variable disables CGO, which is useful for building static binaries. We also set the `GOOS` and `GOARCH` environment variables to `linux` and `amd64`, respectively, to build the binary for the Linux platform.
+    We use the `golang:1.24-alpine` image as the base image for the build stage. The `CGO_ENABLED=0` environment variable disables CGO, which is useful for building static binaries. We also set the `GOOS` and `GOARCH` environment variables to `linux` and `amd64`, respectively, to build the binary for the Linux platform.
 
 2. **Final stage**: This stage uses the official Alpine image as the base and copies the compiled binary from the build stage. It also exposes the application's port and runs the application.
 
-We use the `alpine:3.17` image as the base image for the final stage. We copy the compiled binary from the build stage to the final image. We expose the application's port using the `EXPOSE` instruction and run the application using the `CMD` instruction.
+    We use the `alpine:3.17` image as the base image for the final stage. We copy the compiled binary from the build stage to the final image. We expose the application's port using the `EXPOSE` instruction and run the application using the `CMD` instruction.
 
-Apart from the multi-stage build, the Dockerfile also follows best practices such as using the official images, setting the working directory, and copying only the necessary files to the final image. We can further optimize the Dockerfile by other best practices.
+    Apart from the multi-stage build, the Dockerfile also follows best practices such as using the official images, setting the working directory, and copying only the necessary files to the final image. We can further optimize the Dockerfile by other best practices.
 
 ## Build the Docker image and run the application
 
@@ -97,8 +99,6 @@ Related information:
 
  - [Dockerfile reference](/reference/dockerfile.md)
  - [.dockerignore file](/reference/dockerfile.md#dockerignore-file)
- - [Docker Compose overview](/manuals/compose/_index.md)
- - [Compose file reference](/reference/compose-file/_index.md)
 
 ## Next steps
 

content/guides/go-prometheus-monitoring/develop.md

@@ -8,15 +8,19 @@ aliases:
   - /guides/go-prometheus-monitoring/develop/
 ---
 
-In the last section, we saw how using Docker Compose, we can connect our services together. In this section, we will learn how to develop the Golang application with Docker.
+In the last section, we saw how using Docker Compose, we can connect our services together. In this section, we will learn how to develop the Golang application with Docker. We will also see how to use Docker Compose Watch to rebuild the image whenever we make changes to the code. Lastly, we will test the application and visualize the metrics in Grafana using Prometheus as the datasource.
 
-Now, if we make any changes to our golang application, it needs to reflect in the container, right? To do that, one approach is use --build flag in Docker Compose. It will rebuild all the services which have `build` instruction in the `compose.yml` file. This is how you can use it:
+## Developing the application
+
+Now, if we make any changes to our golang application locally, it needs to reflect in the container, right? To do that, one approach is use --build flag in Docker Compose after making changes in the code. This will rebuild all the services which have `build` instruction in the `compose.yml` file, in our case, the `api` service (golang application).
 
 ```
 docker compose up --build
 ```
 
-But, this is not the best approach. It will rebuild all the services which have `build` instruction. This is not efficient. Every time you make a change in the code, we need to rebuild manually. This is not is not very good flow for development. Another approach is to use Docker Compose Watch. In the `compose.yml` file, under the service `api`, we have added the `develop` section. So, it's more like a hot reloading. Whenever we make changes to code (defined in `path`), it will rebuild the image (or restart depending on the action). This is how you can use it:
+But, this is not the best approach. This is not efficient. Every time we make a change in the code, we need to rebuild manually. This is not is not very good flow for development. 
+
+The better approach is to use Docker Compose Watch. In the `compose.yml` file, under the service `api`, we have added the `develop` section. So, it's more like a hot reloading. Whenever we make changes to code (defined in `path`), it will rebuild the image (or restart depending on the action). This is how you can use it:
 
 ```yaml {hl_lines="17-20",linenos=true}
 services:
@@ -41,11 +45,42 @@ services:
           action: rebuild
 ```
 
-Run the following command to run your application with Compose Watch.
+One you have added the `develop` section in the `compose.yml` file, you can use the following command to start the development server:
 
 ```console
 $ docker compose watch
 ```
 
-Now, if you modify your `main.go` you will see the changes in real time without re-building the image.
+Now, if you modify your `main.go` or any other file in the project, the `api` service will be rebuilt automatically. You will see the following output in the terminal:
+
+```bash
+Rebuilding service(s) ["api"] after changes were detected...
+[+] Building 8.1s (15/15) FINISHED                                                                                                        docker:desktop-linux
+ => [api internal] load build definition from Dockerfile                                                                                                  0.0s
+ => => transferring dockerfile: 704B                                                                                                                      0.0s
+ => [api internal] load metadata for docker.io/library/alpine:3.17                                                                                        1.1s
+  .                             
+ => => exporting manifest list sha256:89ebc86fd51e27c1da440dc20858ff55fe42211a1930c2d51bbdce09f430c7f1                                                    0.0s
+ => => naming to docker.io/library/go-api:latest                                                                                                          0.0s
+ => => unpacking to docker.io/library/go-api:latest                                                                                                       0.0s
+ => [api] resolving provenance for metadata file                                                                                                          0.0s
+service(s) ["api"] successfully built
+```
+
+## Testing the application
+
+Now that we have our application running, Let's head over to Grafana dashboard to visualize the metrics we are registering. Open your browser and navigate to `http://localhost:3000`. You will be greeted with the Grafana login page. The login credentials are the one we have provided in compose file. 
+
+Once you are logged in, you can create a new dashboard. While creating dashboard you will notice that is default datasource is `Prometheus`. This is because we have already configured the datasource in the `grafana.yml` file.
+
+![The optional settings screen with the options specified.](../images/grafana-dash.png)
+
+We can use different panels to visualize the metrics. We will not go into details of Grafana here. You can refer to the [official documentation](https://grafana.com/docs/grafana/latest/) for more information. I created a Bar Gauge panel to visualize the total number of requests from different endpoints. We used the `api_http_request_total` and `api_http_request_error_total` metrics to get the data.
+
+![The optional settings screen with the options specified.](../images/grafana-panel.png)
+
+We created this panel to visualize the total number of requests from different endpoints to compare the successful and failed requests. For all the good requests, the bar will be green, and for all the failed requests, the bar will be red. Plus it will also show the from which endpoint the request is coming, either it's a successful request or a failed request. If you want to use this panel, you can import the `dashboard.json` file from the repo you cloned.
+
+## Summary
 
+That's it! We come to the end of this guide. We learned how to develop the Golang application with Docker. We also saw how to use Docker Compose Watch to rebuild the image whenever we make changes to the code. Lastly, we tested the application and visualized the metrics in Grafana using Prometheus as the datasource.