API key management in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

Designing a scalable API key storage system

You need to design a system to store and validate API keys for millions of users in a microservices environment. Which architectural choice best supports fast validation and scalability?

A Send API keys to an external third-party service for validation on every request.

B Store API keys in a centralized relational database and query it synchronously for every request.

C Use a distributed in-memory cache (like Redis) to store API keys with TTL and validate keys from cache.

D Store API keys in local files on each microservice instance and read from disk on every request.

💡 Hint

Think about latency and load on the database when validating keys for every request.

Using a distributed in-memory cache like Redis allows fast lookups with low latency and supports scalability by reducing load on the database.

🧠 Conceptual

intermediate

API key rotation strategy

What is the best practice for rotating API keys to maintain security without disrupting service?

A Rotate keys only when a security breach is detected.

B Allow old keys to remain valid for a grace period while new keys are issued and accepted.

C Never revoke old keys to avoid any service disruption.

D Immediately revoke old keys and force all clients to update simultaneously.

💡 Hint

Consider how to avoid downtime during key rotation.

Allowing a grace period where both old and new keys are valid ensures smooth transition without service disruption.

❓ scaling

advanced

Handling API key validation under high load

Your API gateway validates API keys for millions of requests per second. Which approach best reduces latency and avoids bottlenecks?

A Use a local cache on each gateway instance with periodic synchronization from a central store.

B Send all validation requests to a single dedicated validation microservice.

C Validate API keys synchronously by querying the database for each request.

D Disable API key validation during peak load to improve throughput.

💡 Hint

Think about reducing network calls and avoiding single points of failure.

Using a local cache on each gateway instance reduces latency and avoids bottlenecks by minimizing calls to central storage.

❓ tradeoff

advanced

Choosing between API key length and usability

Longer API keys increase security but reduce usability. What is the best tradeoff approach?

A Use short keys (e.g., 8 characters) to maximize usability even if security is weaker.

B Use no API keys and rely only on IP whitelisting.

C Use very long keys (e.g., 256 characters) to maximize security regardless of usability.

D Use moderately long keys (e.g., 32 characters) combined with HTTPS and rate limiting.

💡 Hint

Consider balancing security and user experience.

Moderate key length with transport security and rate limiting balances security and usability effectively.

❓ estimation

expert

Estimating storage requirements for API keys

You expect 10 million active API keys, each 40 characters long. Each key record stores the key, user ID (8 bytes), creation timestamp (8 bytes), and status (1 byte). Estimate the approximate storage needed in gigabytes (GB) for all keys, assuming UTF-8 encoding (1 byte per character) and ignoring database overhead.

A Approximately 0.5 GB

B Approximately 2.0 GB

C Approximately 1.0 GB

D Approximately 4.0 GB

💡 Hint

Calculate total bytes per record and multiply by number of keys, then convert to GB (1 GB = 1,073,741,824 bytes).

Each key: 40 bytes (characters) + 8 bytes (user ID) + 8 bytes (timestamp) + 1 byte (status) = 57 bytes per record.
10 million keys × 57 bytes = 570 million bytes ≈ 543 MB ≈ 0.5 GB.

Practice

1. What is the primary purpose of API key management in microservices?

easy

A. To generate random data for APIs

B. To speed up API response times

C. To store user passwords securely

D. To control and monitor access to APIs

Solution

1. Step 1: Understand API key management role

   API key management is about controlling who can use APIs and tracking their usage.

2. Step 2: Identify the main goal

   The main goal is to secure APIs by controlling and monitoring access, not speeding up or storing passwords.

3. Final Answer:

   To control and monitor access to APIs -> Option D

4. Quick Check:

   API key management = Access control [OK]

Hint: API keys control who uses your API [OK]

Common Mistakes:

• Confusing API keys with password storage
• Thinking API keys improve speed
• Assuming API keys generate data

2. Which of the following is the correct way to represent an API key in a request header?

easy

A. Auth-Key: <API_KEY>

B. Authorization: Bearer <API_KEY>

C. API-Key: <API_KEY>

D. Key: <API_KEY>

Solution

1. Step 1: Review common API key header formats

   API keys are often sent in headers named API-Key or similar, but Authorization: Bearer is usually for tokens, not API keys.

2. Step 2: Identify the standard header for API keys

   API-Key is the widely accepted header for API keys, making API-Key: <API_KEY> correct.

3. Final Answer:

   API-Key: <API_KEY> -> Option C

4. Quick Check:

   API key header = API-Key [OK]

Hint: API keys use 'API-Key' header, not 'Authorization: Bearer' [OK]

Common Mistakes:

• Using 'Authorization: Bearer' for API keys
• Confusing header names
• Omitting the key value

3. Given this pseudocode for API key validation:

function validateKey(request) {
  key = request.headers['API-Key']
  if key is null or key not in validKeys:
    return 'Access Denied'
  else:
    return 'Access Granted'
}

What will be the output if the request has no 'API-Key' header?

medium

A. Access Denied

B. Error: Missing header

C. Access Granted

D. Access Pending

Solution

1. Step 1: Check header presence condition

   The code checks if the key is null or not in validKeys. If the header is missing, key is null.

2. Step 2: Determine the return value for missing key

   Since key is null, the condition is true, so the function returns 'Access Denied'.

3. Final Answer:

   Access Denied -> Option A

4. Quick Check:

   Missing key = Access Denied [OK]

Hint: No API-Key header means deny access [OK]

Common Mistakes:

• Assuming missing key grants access
• Expecting an error instead of denial
• Confusing 'null' with empty string

4. A developer wrote this code snippet to revoke an API key:

function revokeKey(key) {
  if key in activeKeys:
    activeKeys.remove(key)
  else:
    print('Key not found')
}

But the key is still accepted after revocation. What is the likely issue?

medium

A. The remove method does not delete keys properly

B. The key is not removed from the validKeys list used for validation

C. The function does not print 'Key revoked' message

D. The key is being re-added automatically elsewhere

Solution

1. Step 1: Understand key revocation logic

   The function removes the key from activeKeys, but validation likely checks validKeys.

2. Step 2: Identify mismatch in key storage

   If validation uses validKeys and revoke removes from activeKeys, the key remains valid.

3. Final Answer:

   The key is not removed from the validKeys list used for validation -> Option B

4. Quick Check:

   Revocation must remove key from validation list [OK]

Hint: Revoking must remove key from validation store [OK]

Common Mistakes:

• Removing key from wrong list
• Assuming print messages affect logic
• Ignoring other code re-adding keys

5. You need to design an API key management system for a microservices platform that supports millions of users. Which approach best balances security, scalability, and ease of revocation?

hard

A. Store API keys in a centralized database with caching and use short-lived keys with rotation

B. Embed API keys directly in client apps without server validation

C. Use a single global API key for all users to simplify management

D. Store API keys only in memory on each microservice without persistence

Solution

1. Step 1: Evaluate security and scalability needs

   Millions of users require scalable storage and fast validation. Centralized DB with caching supports this.

2. Step 2: Consider revocation and key rotation

   Short-lived keys with rotation improve security and allow easy revocation without downtime.

3. Step 3: Eliminate insecure or unscalable options

   Embedding keys in clients or using a single key is insecure; in-memory only storage lacks persistence and scalability.

4. Final Answer:

   Store API keys in a centralized database with caching and use short-lived keys with rotation -> Option A

5. Quick Check:

   Central DB + caching + rotation = secure & scalable [OK]

Hint: Use central DB with caching and rotate keys regularly [OK]

Common Mistakes:

• Using single global key for all users
• Not persisting keys for revocation
• Embedding keys insecurely in clients