How to Monitor Running Docker Containers on Linux Server - Complete Container Monitoring Guide

Are you wondering how to check and monitor running Docker containers on your Linux server? Need to detect when containers stop or new containers appear unexpectedly? This comprehensive guide shows you multiple methods to monitor running Docker containers, detect container failures automatically, track container status changes, and maintain containerized application availability on your Linux server.

Why Monitoring Running Docker Containers Matters

Docker containers are the foundation of modern containerized applications on Linux servers. Containers run everything from web applications and databases to microservices and background workers. When containers stop unexpectedly or fail to start, your applications become unavailable, services can fail, and users experience downtime. Learning how to monitor running Docker containers helps you detect container failures immediately, ensure application availability, track container status changes, and troubleshoot container issues quickly. Regular container monitoring prevents extended outages and helps you maintain high availability for your containerized infrastructure.

Method 1: List Running Containers with docker ps

The docker ps command is the primary tool for checking running Docker containers on Linux servers. This command provides quick access to container status and information.

Basic Container Listing

To see all running containers:

# List all running containers
docker ps

# List all containers including stopped
docker ps -a

# List containers with full command output
docker ps --no-trunc

# List containers with specific format
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

The docker ps command shows container ID, image, command, creation time, status, ports, and names by default.

Detailed Container Information

To get more detailed information about containers:

# Show containers with custom format
docker ps --format "{{.Names}}: {{.Status}} ({{.Image}})"

# Show containers with sizes
docker ps -s

# Show containers with labels
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Label \"com.example.version\"}}"

# Show containers with network information
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Networks}}"

Filter Containers

To show specific containers:

# Show containers by name pattern
docker ps --filter "name=nginx"

# Show containers by status
docker ps --filter "status=running"
docker ps --filter "status=exited"

# Show containers by image
docker ps --filter "image=nginx:latest"

# Show containers by label
docker ps --filter "label=environment=production"

Method 2: Check Container Status with docker inspect

The docker inspect command provides detailed information about containers, including their current state and configuration.

Inspect Container Details

To get detailed container information:

# Inspect specific container
docker inspect container-name

# Inspect container state only
docker inspect --format='{{.State.Status}}' container-name

# Inspect container health status
docker inspect --format='{{.State.Health.Status}}' container-name

# Inspect container restart count
docker inspect --format='{{.RestartCount}}' container-name

Check Container Health

To verify container health:

# Check if container is running
docker inspect --format='{{.State.Running}}' container-name

# Check container exit code
docker inspect --format='{{.State.ExitCode}}' container-name

# Check container started at
docker inspect --format='{{.State.StartedAt}}' container-name

# Check container finished at
docker inspect --format='{{.State.FinishedAt}}' container-name

Method 3: Monitor Container Statistics

The docker stats command provides real-time resource usage statistics for running containers.

View Container Statistics

To see container resource usage:

# Show real-time stats for all containers
docker stats

# Show stats without streaming (one snapshot)
docker stats --no-stream

# Show stats for specific containers
docker stats container1 container2

# Show stats with custom format
docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"

Monitor Container Resource Usage

To track container resource consumption:

# Show CPU and memory usage
docker stats --no-stream --format "{{.Name}}: CPU {{.CPUPerc}}, Memory {{.MemUsage}}"

# Show container network I/O
docker stats --no-stream --format "{{.Name}}: Network {{.NetIO}}"

# Show container block I/O
docker stats --no-stream --format "{{.Name}}: Block {{.BlockIO}}"

Method 4: Check Container Logs

Container logs help identify why containers stopped or are experiencing issues.

View Container Logs

To see container logs:

# Show container logs
docker logs container-name

# Show last 100 log lines
docker logs --tail 100 container-name

# Follow container logs
docker logs -f container-name

# Show logs with timestamps
docker logs -t container-name

# Show logs since specific time
docker logs --since "2024-01-01T00:00:00" container-name

Monitor Container Logs for Errors

To detect errors in container logs:

# Show logs with error filtering
docker logs container-name 2>&1 | grep -i error

# Show recent error logs
docker logs --tail 500 container-name | grep -i error

# Monitor logs for specific patterns
docker logs -f container-name | grep -i "exception\|error\|fail"

Method 5: Automated Container Monitoring with Zuzia.app

Manually checking running Docker containers works for occasional audits, but for production Linux servers, you need automated monitoring that alerts you when containers stop or new containers appear. Zuzia.app provides comprehensive container monitoring through scheduled command execution.

Setting Up Automated Container Monitoring

1. Add Scheduled Task in Zuzia.app Dashboard

   • Navigate to your server in Zuzia.app
   • Click "Add Scheduled Task"
   • Choose "Command Execution" as the task type

2. Configure Container Check Command

   • Enter command: docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Image}}"
   • Set execution frequency: Every 15 minutes for active monitoring
   • Configure alert conditions: Alert when expected containers are not running
   • Set up comparison with previous runs to detect changes

3. Set Up Notifications

   • Choose notification channels (email, webhook, Slack, etc.)
   • Configure alert thresholds (e.g., alert if critical container stops)
   • Set up escalation rules for critical containers
   • Configure different alert levels for different container types

Monitor Specific Containers

For mission-critical containers, create dedicated monitoring tasks:

# Check specific critical containers
docker ps --filter "name=nginx" --filter "name=mysql" --filter "name=redis"

# Check containers by label
docker ps --filter "label=critical=true"

# Count running containers
docker ps -q | wc -l

# Verify expected containers are running
EXPECTED="nginx mysql redis"
for container in $EXPECTED; do
  docker ps --format "{{.Names}}" | grep -q "^${container}$" || echo "Container $container is not running"
done

Zuzia.app stores all command outputs in its database, allowing you to track container status over time, identify containers that frequently restart, and detect container failures before they cause extended outages.

Method 6: Advanced Container Monitoring Techniques

Beyond basic checks, you can use advanced techniques to monitor containers more effectively.

Count Containers by Status

To get container counts:

# Count running containers
docker ps -q | wc -l

# Count stopped containers
docker ps -a -f "status=exited" -q | wc -l

# Count containers by status
docker ps -a --format "{{.State}}" | sort | uniq -c

# Count containers per image
docker ps -a --format "{{.Image}}" | sort | uniq -c

Detect Container Restarts

To identify containers that restart frequently:

# Show containers with restart count
docker ps -a --format "{{.Names}}: {{.RestartCount}} restarts"

# Find containers that restarted recently
docker ps -a --format "table {{.Names}}\t{{.Status}}\t{{.RestartCount}}" | grep -E "Restarting|restarted"

# Check container restart policy
docker inspect --format='{{.HostConfig.RestartPolicy.Name}}' container-name

Monitor Container Health Checks

To check container health status:

# Show containers with health status
docker ps --format "table {{.Names}}\t{{.Status}}" | grep -i health

# Check health status for specific container
docker inspect --format='{{json .State.Health}}' container-name | jq

# List unhealthy containers
docker ps --format "{{.Names}}: {{.Status}}" | grep -i unhealthy

Real-World Use Cases for Container Monitoring

Application Availability Monitoring

For application servers, monitor critical application containers:

# Check web application containers
docker ps --filter "name=webapp" --filter "name=api"

# Check database containers
docker ps --filter "name=mysql" --filter "name=postgres"

# Check cache containers
docker ps --filter "name=redis" --filter "name=memcached"

# Verify all application containers are running
docker ps --format "{{.Names}}" | grep -E "webapp|api|worker" | wc -l

Container Failure Detection

For failure detection, identify stopped or failed containers:

# List stopped containers
docker ps -a --filter "status=exited"

# List containers that exited with errors
docker ps -a --filter "status=exited" --format "{{.Names}}: Exit Code {{.State.ExitCode}}"

# Check containers that crashed
docker ps -a --format "{{.Names}}: {{.Status}}" | grep -i "exited\|dead"

Container Resource Monitoring

For resource management, monitor container resource usage:

# Show container CPU and memory usage
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# Identify containers using most CPU
docker stats --no-stream --format "{{.Name}}: {{.CPUPerc}}" | sort -t: -k2 -rn | head -5

# Identify containers using most memory
docker stats --no-stream --format "{{.Name}}: {{.MemUsage}}" | sort -t: -k2 -rn | head -5

Best Practices for Container Monitoring

1. Monitor Containers Regularly

Check running containers every 15-30 minutes for active monitoring, and more frequently (every 5 minutes) for critical containers. This allows you to detect failures immediately and respond quickly. Use Zuzia.app automated monitoring to check containers continuously without manual intervention.

2. Focus on Critical Containers

While monitoring all containers is important, prioritize critical containers that impact your infrastructure: web servers, databases, application services, and monitoring tools. Create dedicated monitoring tasks for these containers with more frequent checks and immediate alerts.

3. Track Container Restart Frequency

Monitor container restart counts over time to identify containers that restart frequently. Containers that restart repeatedly might indicate configuration issues, resource constraints, or application problems. Use Zuzia.app's historical data to track restart patterns and identify root causes.

4. Monitor Container Health Checks

If containers have health checks configured, monitor health status separately. Health checks provide more detailed information about container state than basic running status. Set up alerts for unhealthy containers to detect issues before containers crash.

5. Document Expected Containers

Maintain documentation about expected containers. Document which containers should be running, their images, and their purposes. Update documentation when container configurations change.

Troubleshooting Common Container Issues

Container Not Running

If a container is not running:

# Check container status
docker ps -a | grep container-name

# Check container logs
docker logs container-name

# Check container exit code
docker inspect --format='{{.State.ExitCode}}' container-name

# Check container restart policy
docker inspect --format='{{.HostConfig.RestartPolicy.Name}}' container-name

Container Keeps Restarting

If a container keeps restarting:

# Check restart count
docker inspect --format='{{.RestartCount}}' container-name

# View recent logs
docker logs --tail 100 container-name

# Check container health
docker inspect --format='{{json .State.Health}}' container-name

# Check resource limits
docker inspect --format='{{.HostConfig.Memory}}' container-name

Container Resource Issues

If containers are using too many resources:

# Check container resource usage
docker stats --no-stream container-name

# Check container resource limits
docker inspect --format='{{.HostConfig.Memory}} {{.HostConfig.CpuShares}}' container-name

# Check container resource usage over time
docker stats --no-stream --format "{{.Name}}: CPU {{.CPUPerc}}, Memory {{.MemUsage}}"

FAQ: Common Questions About Monitoring Running Docker Containers

How often should I check running Docker containers on my Linux server?

We recommend checking running containers every 15-30 minutes for active monitoring, and every 5 minutes for critical containers. This allows you to detect failures immediately and respond quickly. Use Zuzia.app automated monitoring to check containers continuously without manual intervention.

What should I do when a container stops?

When a container stops, first check the container logs using docker logs container-name to understand why it stopped. Then check the container exit code with docker inspect --format='{{.State.ExitCode}}' container-name. If the container should be running, restart it with docker start container-name. Investigate the root cause (application errors, resource constraints, configuration issues) before restarting to prevent repeated failures.

Can I monitor specific containers instead of all containers?

Yes, you can check specific containers using docker ps --filter "name=container-name" or by creating separate monitoring tasks in Zuzia.app for each critical container. This allows you to set different alert thresholds and notification channels for different container types. Monitoring specific containers also reduces system load compared to checking all containers.

How do I see why a container stopped or failed?

Use docker logs container-name to view container logs and identify error messages or failure reasons. Check the container exit code with docker inspect --format='{{.State.ExitCode}}' container-name - non-zero exit codes indicate errors. Check container health status with docker inspect --format='{{json .State.Health}}' container-name if health checks are configured.

What's the difference between docker ps and docker ps -a?

The docker ps command shows only running containers, while docker ps -a shows all containers including stopped ones. Use docker ps for quick checks of running containers, and docker ps -a when you need to see stopped containers or check container history.

Can I automatically restart containers when they stop?

Yes, Docker supports restart policies that automatically restart containers. Set restart policies when creating containers with --restart=always or --restart=unless-stopped. However, use caution - automatic restarts might cause issues if containers fail due to configuration errors. Always investigate the root cause of failures before relying on automatic restarts.

Does Zuzia.app track container status history and patterns?

Yes, Zuzia.app stores all command outputs in its database, allowing you to track container status over time and identify patterns. You can view historical data to see which containers stop most frequently, when containers restart, and how often containers need to be restarted manually. This helps you identify root causes and prevent recurring container failures.