Mutual TLS between services in Microservices - Architecture Diagram

System Overview - Mutual TLS between services

This system enables secure communication between microservices using Mutual TLS (mTLS). Each service authenticates the other by exchanging certificates, ensuring encrypted and trusted connections. Key requirements include strong authentication, data encryption in transit, and prevention of unauthorized access.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  v
+-------------------+       +-------------------+
|   Service A       |<----->|   Service B       |
| (mTLS Client &    |       | (mTLS Server &    |
|  Server)          |       |  Client)          |
+-------------------+       +-------------------+
       |                            |
       v                            v
+--------------+             +--------------+
| Certificate  |             | Certificate  |
| Authority    |             | Authority    |
+--------------+             +--------------+
       |                            |
       +------------+  +------------+
                    |  |
                 +-------------------+
                 |  Database          |
                 +-------------------+

Components

User

user

Initiates requests to the system

Load Balancer

load_balancer

Distributes incoming traffic evenly across API Gateway instances

API Gateway

api_gateway

Handles client requests, routing them to appropriate services

Service A

service

Microservice acting as both mTLS client and server to communicate securely with Service B

Service B

service

Microservice acting as both mTLS server and client to communicate securely with Service A

Certificate Authority

certificate_authority

Issues and manages certificates for services to enable mutual TLS authentication

Database

database

Stores persistent data accessed by services

Request Flow - 9 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Service A

Service A → Service B

Service B → Database

Service B → Service A

Service A → API Gateway

API Gateway → Load Balancer

Load Balancer → User

Failure Scenario

Component Fails:Certificate Authority

Impact:New certificates cannot be issued or renewed, causing mTLS authentication failures between services

Mitigation:Use multiple redundant CAs with automated failover and certificate rotation to maintain trust

Architecture Quiz - 3 Questions

Which component ensures that Service A and Service B trust each other’s identity?

A API Gateway

B Load Balancer

C Certificate Authority

D Database

Design Principle

This architecture uses Mutual TLS to provide strong, bidirectional authentication and encryption between microservices. It ensures that only trusted services communicate, protecting data in transit and preventing unauthorized access. The use of a Certificate Authority centralizes trust management, while the Load Balancer and API Gateway handle traffic routing and scalability.

Practice

1. What is the main purpose of using Mutual TLS between microservices?

easy

A. To allow services to communicate without encryption

B. To speed up the communication between services

C. To ensure both services authenticate each other before communication

D. To store service data securely on disk

Solution

1. Step 1: Understand Mutual TLS authentication

   Mutual TLS requires both client and server to present certificates proving their identity.

2. Step 2: Identify the purpose in microservices

   This ensures only trusted services communicate securely, preventing unauthorized access.

3. Final Answer:

   To ensure both services authenticate each other before communication -> Option C

4. Quick Check:

   Mutual TLS = mutual authentication [OK]

Hint: Mutual TLS means both sides prove who they are [OK]

Common Mistakes:

• Thinking it only encrypts data without authentication
• Assuming it speeds up communication
• Confusing it with data storage security

2. Which of the following is the correct step to enable Mutual TLS in a microservice?

easy

A. Disable certificate verification on both services

B. Share the same private key among all services

C. Use plain HTTP instead of HTTPS

D. Configure each service with its own certificate and trust store

Solution

1. Step 1: Identify certificate requirements

   Each service must have its own certificate and trust store to verify others.

2. Step 2: Understand security best practices

   Disabling verification or sharing keys breaks security and is incorrect.

3. Final Answer:

   Configure each service with its own certificate and trust store -> Option D

4. Quick Check:

   Certificates + trust store = Mutual TLS setup [OK]

Hint: Each service needs its own certificate and trust store [OK]

Common Mistakes:

• Disabling certificate verification to simplify setup
• Using HTTP which is unencrypted
• Sharing private keys causing security risks

3. Given two microservices A and B configured with Mutual TLS, what happens if service B presents an expired certificate during handshake?

medium

A. Service A accepts the connection without checks

B. Service A rejects the connection due to invalid certificate

C. Service B automatically renews the certificate

D. The connection proceeds but logs a warning

Solution

1. Step 1: Understand certificate validation in Mutual TLS

   Certificates must be valid and trusted; expired certificates are rejected.

2. Step 2: Identify handshake behavior on invalid certificates

   If service B's certificate is expired, service A will reject the connection to maintain security.

3. Final Answer:

   Service A rejects the connection due to invalid certificate -> Option B

4. Quick Check:

   Expired certificate = connection rejected [OK]

Hint: Expired cert means connection is rejected [OK]

Common Mistakes:

• Assuming expired certs are accepted with warnings
• Thinking certificates auto-renew during handshake
• Believing connection proceeds without checks

4. A microservice fails to establish Mutual TLS with another service. The error logs show "certificate unknown". What is the most likely cause?

medium

A. The service's certificate is not signed by a trusted CA

B. The service is using HTTP instead of HTTPS

C. The private key is missing from the service

D. The service is using a self-signed certificate but trusts it

Solution

1. Step 1: Analyze the error "certificate unknown"

   This error means the certificate presented is not recognized or trusted by the other service.

2. Step 2: Identify cause related to trust

   If the certificate is not signed by a trusted CA, the other service will reject it as unknown.

3. Final Answer:

   The service's certificate is not signed by a trusted CA -> Option A

4. Quick Check:

   Untrusted CA = certificate unknown error [OK]

Hint: Certificate unknown means untrusted CA signature [OK]

Common Mistakes:

• Confusing HTTP usage with certificate errors
• Assuming missing private key causes this error
• Believing self-signed certs are trusted by default

5. You need to design a microservices system with Mutual TLS where services dynamically scale up and down. Which approach best ensures secure and scalable certificate management?

hard

A. Use a centralized certificate authority with automated certificate issuance and rotation

B. Manually generate and distribute certificates to each service instance

C. Disable Mutual TLS during scaling to avoid certificate issues

D. Use the same certificate for all service instances to simplify management

Solution

1. Step 1: Understand challenges of scaling with Mutual TLS

   Dynamic scaling requires automated certificate management to avoid manual errors and delays.

2. Step 2: Evaluate options for secure and scalable management

   A centralized CA with automation allows issuing and rotating certificates securely as instances scale.

3. Step 3: Reject insecure or manual approaches

   Manual distribution is error-prone, disabling TLS reduces security, and sharing certificates risks compromise.

4. Final Answer:

   Use a centralized certificate authority with automated certificate issuance and rotation -> Option A

5. Quick Check:

   Central CA + automation = scalable Mutual TLS [OK]

Hint: Automate certs with central CA for scaling [OK]

Common Mistakes:

• Manually managing certs for each instance
• Disabling Mutual TLS to avoid complexity
• Sharing certificates across instances