Hoe beveilig je service-to-service communicatie (mTLS, zero-trust)?

Question

Accepted Answer

Binnen een microservices netwerk kun je het netwerk niet vertrouwen alleen omdat het "intern" is. **Zero-trust** gaat ervan uit dat het netwerk vijandelijk is, dus elke aanroep wordt geverifieerd en geautoriseerd, en het verkeer is versleuteld met **mTLS**.

## Mutual TLS (mTLS)

In tegenstelling tot normale TLS presenteren **beide** zijden certificaten. Elke service bewijst zijn identiteit, en het verkeer is in transit versleuteld.

```text
Service A ──cert──▶ Service B
Service A ◀─cert── Service B   (both verify each other's identity)
→ caller is authenticated AND data is encrypted
```

Een service mesh kan mTLS automatisch leveren zonder wijzigingen in appcode.

## Service-to-service autorisatie

Identiteit (wie roept) plus beleid (wat ze mogen doen). Tokens (JWT) of SPIFFE-identiteiten dragen de identiteit van de aanroeper.

```yaml
# allow only the orders service to call payments
policy:
  from: { service: orders }
  to:   { service: payments, path: /charge }
  action: ALLOW            # everything else denied by default
```

## Verdediging in diepte

```text
✓ Authenticate every request (no implicit network trust)
✓ Least privilege — a service can call only what it needs
✓ Short-lived, rotated credentials/certs
✓ Validate tokens at the edge AND between services
✓ Encrypt in transit (mTLS) and at rest
```

## Valkuil

Het vertrouwen van het interne netwerk ("het zit achter de firewall") is hoe een enkele ingebroken service een volledig compromis wordt.

## Waarom het belangrijk is

In een plat intern netwerk kan één gecompromitteerde service op zich alles bereiken; zero-trust beperkt die explosiestraal.

mTLS plus autorisatie per aanroep betekent dat een aanvaller die erin is geland nog steeds geen services kan imiteren of lateraal kan bewegen, wat de kernbelofte van een modern microservices-platform is.