Hoe handle je logging en monitoring voor containers?

Question

IT Interview Practice · Accepted Answer

Gecontaineriseerde applicaties hebben **centralized logging** en **monitoring** nodig omdat containers ephemeral en talrijk zijn — logs en metrics moeten extern worden verzameld zodat ze behouden blijven nadat containers worden verwijderd en zichtbaarheid over het hele systeem bieden. Dit is essentiële observability voor production containers.

## Logging: naar stdout/stderr, centraal aggregeren

```text
BEST PRACTICE: containers should log to STDOUT/STDERR (not to files inside the container):
  → Docker captures these (`docker logs`); a logging DRIVER forwards them elsewhere
  → WHY: containers are EPHEMERAL — logs in a removed container are LOST. Centralize them.
```

```text
Logging drivers / pipelines forward logs to a central system:
  → json-file (default), syslog, fluentd, awslogs, gelf, etc. (--log-driver)
  → Aggregation stacks: ELK/Elastic (Elasticsearch+Logstash+Kibana), Loki+Grafana,
    cloud logging (CloudWatch, Stackdriver), Datadog, etc.
→ Centralized logs: searchable, persistent, span ALL containers/hosts → real visibility
```

## Monitoring: metrics, health, alerts

```text
✓ METRICS — collect CPU, memory, network, app metrics per container
  → Prometheus (scrapes metrics) + Grafana (dashboards) — the common stack
  → cAdvisor / node-exporter for container/host metrics
✓ HEALTH — health checks + orchestrator status (which containers are healthy)
✓ ALERTING — alert on failures, resource limits, errors (Alertmanager, etc.)
✓ DISTRIBUTED TRACING — trace requests across microservices (Jaeger, OpenTelemetry)
```

## Waarom container observability anders is

```text
Containers are EPHEMERAL (created/destroyed dynamically) and NUMEROUS (many across hosts):
  → can't rely on logging into a box or local log files (containers come and go)
  → need EXTERNAL, centralized, dynamic collection that handles churn
  → orchestrators add labels/metadata to correlate logs/metrics to services
→ Observability must be designed for dynamic, distributed, ephemeral workloads.
```

## Waarom het belangrijk is

Het begrijpen van logging en monitoring voor containers is belangrijke senior-level kennis omdat **observability essentieel is voor het beheren van production systems**, en de ephemeral, talrijke, gedistribueerde aard van containers maakt het anders dan traditionele benaderingen.

De kernpraktijk voor **logging** — containers moeten naar **stdout/stderr** loggen (niet naar bestanden binnen de container) zodat het platform deze opvangt en doorstuurt naar **centralized aggregation** — is cruciaal omdat **containers ephemeral zijn**: logs opgeslagen binnen een container gaan **verloren wanneer deze wordt verwijderd**, dus het centraliseren van logs (via logging drivers naar ELK, Loki/Grafana, cloud logging, etc.) is nodig om logs te behouden en zichtbaarheid over alle containers en hosts te verkrijgen. **Monitoring** is even essentieel: het verzamelen van **metrics** (CPU, geheugen, application metrics, meestal via Prometheus + Grafana), het bijhouden van **health** (health checks en orchestrator status), **alerting** op problemen, en **distributed tracing** (requests volgen over microservices met Jaeger/OpenTelemetry) bieden de zichtbaarheid die nodig is om systeemgedrag te begrijpen, problemen op te sporen en te reageren op issues.

Het begrijpen van **waarom container observability anders is** — containers zijn ephemeral (dynamisch gemaakt/verwijderd, dus je kunt niet vertrouwen op lokale bestanden of inloggen op machines) en talrijk over hosts (wat externe, dynamische verzameling vereist die omgaat met churn, met orchestrator metadata die logs/metrics koppelt aan services) — is het conceptuele inzicht dat vormt hoe observability moet worden ontworpen voor gecontaineriseerde systemen.

Omdat het beheren van production systems observability vereist (je kunt niet beheren wat je niet kunt zien), en omdat de ephemeral, gedistribueerde aard van containers gecentraliseerde, extern verzamelde logging en monitoring vraagt die ontworpen zijn voor dynamische workloads, is het begrijpen van container logging en monitoring belangrijke senior-level kennis voor het verantwoord uitvoeren van gecontaineriseerde applicaties — essentiële observability die gecontaineriseerde systemen operabel, debugbaar en onderhoudbaar maakt in production, en een afspiegeling van de operationele volwassenheid die verwacht wordt voor senior rollen die container deployments beheren.

Logging: naar stdout/stderr, centraal aggregeren

Monitoring: metrics, health, alerts

Waarom container observability anders is

Waarom het belangrijk is

Gerelateerde vragen