Hvordan håndterer du logging og monitoring for containere?

Question

Accepted Answer

Containeriserede applikationer har brug for **centraliseret logging** og **monitoring**, fordi containere er kortlivede og talrige — logs og metrics skal indsamles eksternt, så de overlever containerfjernelse og giver indsigt på tværs af hele systemet. Dette er essentiel observabilitet for produktionscontainere.

## Logging: log til stdout/stderr, aggreger centralt

```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)
```

## Hvorfor containerobservabilitet er anderledes

```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.
```

## Hvorfor det betyder noget

At forstå logging og monitoring for containere er vigtig viden på seniorniveau, fordi **observabilitet er essentiel for at drive produktionssystemer**, og containeres kortlivede, talrige, distribuerede natur gør det anderledes end traditionelle tilgange.

Den vigtigste **logging**-praksis — containere bør **logge til stdout/stderr** (ikke til filer inden i containeren), så platformen kan registrere og videresende dem til **centraliseret aggregering** — er afgørende, fordi **containere er kortlivede**: logs gemt inden i en container **går tabt, når den fjernes**, så centralisering af dem (via logging drivers til ELK, Loki/Grafana, cloud logging osv.) er nødvendig for at bevare logs og få indsigt på tværs af alle containere og værter. **Monitoring** er lige så essentielt: indsamling af **metrics** (CPU, hukommelse, applikationsmetrics, almindeligvis via Prometheus + Grafana), sporing af **health** (health checks og orchestrator-status), **alerting** på problemer og **distributed tracing** (forfølgelse af requests på tværs af microservices med Jaeger/OpenTelemetry) giver den indsigt, der er nødvendig for at forstå systemopførelse, diagnosticere problemer og reagere på fejl.

At forstå **hvorfor containerobservabilitet er anderledes** — containere er kortlivede (oprettet/fjernet dynamisk, så du kan ikke stole på lokale filer eller logge på maskiner) og talrige på tværs af værter (hvilket kræver ekstern, dynamisk indsamling, der håndterer omsætning, med orchestrator-metadata, der korrelerer logs/metrics til tjenester) — er det begrebsmæssige indsigt, der former, hvordan observabilitet skal være designet for containeriserede systemer.

Fordi drift af produktionssystemer kræver observabilitet (du kan ikke administrere det, du ikke kan se), og fordi containeres kortlivede, distribuerede natur kræver centraliseret, eksternt indsamlet logging og monitoring designet til dynamiske workloads, er forståelse af containerlogging og -monitoring vigtig viden på seniorniveau for at køre containeriserede applikationer ansvarligt — essentiel observabilitet, der gør containeriserede systemer operabel, debuggable og vedligeholdbar i produktionen, og en afspejling af den operationelle modenhed, der forventes for seniorrollen med at administrere containerdeployments.