Easy Guide to Docker Compose Logs: How to Check and Manage

Do you want to know what Docker apps are doing behind the scenes? Let’s learn more about the secret window, known as logs, into your containers that show every move they make. The logs are super helpful for fixing problems. But before we start, let’s take a quick look at what Docker and Docker Compose are.

[lwptoc]

Docker allows you to package your applications into small containers and run them on most operating systems without any dependencies. It’s like putting your apps in little boxes called Containers, which can run the same way everywhere. Knowing about containers is an important prerequisite in learning about Docker compose. So, I encourage you first to read our blog on the benefits of containerization.

Docker Compose comes with Docker and simplifies developing multiple containerized applications by chaining their services, networks, and storage. Docker container logs and Docker Compose logging help developers see what each container does.

So, are you curious about Docker Compose Logs? You are in the right place. This blog will explain the basics of Docker Compose logs and cover more advanced details. Learn how to make the most of Docker Compose for your projects.

The Importance of Docker Compose Logs

Imagine a developer launches an app with Docker but skips setting up Docker logs. At first, everything seems fine. But soon, users find errors, and the app slows down. Without Docker logs, the developer can’t see what went wrong inside the Docker containers. Docker Compose logs are like a detailed record of these containers. They record every detail of what happens, which is important for finding and fixing problems later.

As a Developer or System Admin, you must understand what happens inside and between multi-chain applications. This is where Docker Compose logs act as a handy tool. So, why are these logs necessary?

• Troubleshooting and Debugging

Check docker logs when an application isn’t running correctly or encounters errors. Docker logs are the first resources you can look at to trace the issue. By examining the docker logs, developers can pinpoint the root cause and source of problems, whether it’s a bug in the code, a misconfiguration, or resource issues.

• Monitoring Application Health

Regularly monitoring application logs helps to understand the overall health of services. Logs can reveal early warning signs, such as repeated errors and slow responses. Observing these patterns early can prevent potential issues in the future.

• Audit and Compliance

For applications that need to follow specific standards, docker logs are the first piece of evidence showing whether the application adheres to guidelines. These logs also play an essential role in monitoring authorized or unauthorized activities.

• Optimization

Logs are valuable resources for software optimization by providing performance data. For instance, developers can identify slow-running queries, inefficient code paths, or underutilized resources.

[rh-cta-related pid=”19816″]

Crafting a Docker Recipe: Deploying a Web Server

In this section, we’ll walk through creating a Docker recipe together. We first need to build something to start our journey with Docker Compose logs. Let’s deploy a web server for this purpose. To create a Dockerfile, simply run nano Dockerfile in the desired folder on your VPS with the following contents and then save it:

 

FROM nginx:alpine
RUN rm /usr/share/nginx/html/index.html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

So, what does each line of this code do?

• We start with a lightweight base, nginx:alpine.
• Next, we clear out the default welcome page of Nginx.
• Then, we make sure that the web server is listening on port 80.
• Finally, we run the Nginx server with CMD.

Now our Dockerfile is ready, we’ll move on to the next step, which is creating the Docker Compose file. Here’s the structure of the docker-compose.yml file:

version: '3.8'
services:
web:
build: .
ports:
- "8080:80"
volumes:
- ./index.html:/usr/share/nginx/html/index.html

Let’s break it down to understand each part completely:

• We’re using version 3.8.
• On the next line, we name our service “web“.
• Then, we instruct Docker to build our web server from the current folder.
• We link port 8080 on our host to port 80 in our container to enable our web server to establish a connection.
• Finally, the volumes configuration maps index.html from the host disk to the container. Later, you can create an index.html file with any content you want and place it where the Dockerfile and docker-compose.yml files exist.

Now it’s time to run our Docker container with Docker Compose. Simply, we run docker-compose up.

Once you run the docker-compose up command, Docker will download the required images from the internet and configure them as instructed in our configuration files.

To check if our web server is up and running, open your web browser, type in your VPS IP address, and request access to port 8080.

As a side note, you can use docker-compose up -d to run the container in the background.

Accessing Logs with Docker Compose

Now, our web server is ready, up, and running. It’s already generating logs and storing this information for later use. Accessing your docker compose logs is essential for troubleshooting and monitoring. But how can we read these logs? This is where docker-compose logs comes in handy. Make sure you are in the folder where the configuration exists, and run that command.

Sometimes, you might want to see the live version of the logs as they are generating. Simply add -f at the end of the previous command and run docker-compose logs -f.

Some Docker-based applications may not provide you with timestamps in their logs. Therefore, you can use docker-compose logs -t to add a recorded time for each line of the log.

Docker Logs can also display the most recent entries. To achieve this, use docker-compose logs –tail 10 to view the latest 10 log entries. Docker composes logs tail, and similarly docker logs tail is particularly useful when you want to quickly check recent activity without scrolling through the entire log history.

The primary purpose of using Docker Compose is to create multi-container applications. Therefore, you may need to read specific logs for a desired service. To do so, use docker-compose logs -f SERVICE, remembering to replace SERVICE with your actual service name.

Docker Logging

The Docker ecosystem can become more complex for converged applications, especially in large environments. As we already know, each container generates logs. Therefore, a mechanism known as the Logging Driver is responsible for receiving, delivering, and storing logs. By default, Docker uses JSON files for the Logging Driver, but it also supports various other drivers, each with their pros and cons.

Everyone agrees that logs are crucial in various areas, including troubleshooting and enhancing system performance. Below, we will cover two of the main aspects of using container logs:

• Monitoring: Logs’ primary purpose is monitoring. They generally reveal the overall health of our containerized applications.
• Troubleshooting: In the event of issues, logs help us detect application glitches.

As docker logs and docker compose logs are continuously generated, they may fill up all the VPS storage. Therefore, we need a strategy to manage disk space called a Log Rotation Policy. To create and use this policy, return to the docker-compose.yml file and open it. Then, add a logging section with the configuration below:

version: '3.8'
services:
web:
build: .
ports:
- "8080:80"
volumes:
- ./index.htm:/usr/share/nginx/html/index.htm
logging:
driver: json-file
options:
max-size: "200k"
max-file: "10"

You can constantly adjust max-size and max-file according to your needs.

Docker Logs Delivery Models

Engineers might opt for a different logging model in more advanced environments than the default JSON drivers, such as Syslog, fluentd, and others. However, it’s important to remember that the JSON-file driver is suitable for most logging scenarios, and there might not be a need to deviate from the default mode.

Depending on your application’s architecture or organizational requirements, you may be forced to utilize central logging solutions known as Log Aggregators. These services, including Elasticsearch, Logstash, Kibana, etc., are designed to receive logs from various sources and consolidate, store, and analyze them in a single central location.

[rh-cta-related pid=”25028″]

Conversely, you should store your logs using more cost-effective storage solutions. Consider the scenario where your VPS uses high-speed and expensive storage; it may not be economical to utilize such premium resources for storing logs that you might only need for future reference.

Numerous logging models are available, each with advantages and disadvantages. Evaluating each model carefully and selecting one based on your specific needs is essential.

[rh-cta-linux type=”2″ ]

Conclusion

Understanding Docker Compose logs is key. They help manage and debug your Docker applications well. Learning to access and monitor these logs improves problem-solving and boosts your app’s performance and security. Whether developing or administering systems, using Docker Compose logs is essential. They make sure your container management is effective.

FAQ

How can I filter Docker Compose logs by time?

Docker Compose does not offer a direct method to filter logs by time. However, you can filter logs by piping them through grep for pattern matching. For instance, you can use: docker-compose logs | grep “2023-04-06”, replacing “2023-04-06” with the specific date or time pattern you’re searching for.

How to stop containers started with Docker Compose?

Navigate to the directory that contains the docker-compose.yml file and run the command docker-compose down.

How to manually remove log files?

Instead of configuring log rotation in your docker-compose.yml file, you can manually remove Docker JSON log files from /var/lib/docker/containers/<container_id>/. Before doing so, you should identify the Docker container ID with docker ps -a.

Can you tail Docker logs? 

Yes, you can. To so you should use the docker logs command along with the -f or –follow option. This will tail Docker logs for you.