Meta DevOps Engineer Interview Questions

Meta's applications often rely on various configurations across multiple services. A robust configuration manager ensures that the services get the right configurations seamlessly. Your task is to design a ConfigManager class that handles configuration loading and updates.Problem statement: Define the ConfigManager class that stores configurations for different services and provides methods to retrieve and update these configurations.
- def __init__(self): Initializes the configuration manager.
- def set_config(self, service_id: str, config: Dict[str, Any]) -> None: Sets or updates the configuration for a specific service.
- def get_config(self, service_id: str) -> Dict[str, Any]: Retrieves the configuration for a specific service.Example 1:
Input: config_manager = ConfigManager(); config_manager.set_config('auth_service', {'retry_limit': 3}); config = config_manager.get_config('auth_service')
Output: {'retry_limit': 3}
Explanation: The configuration for 'auth_service' is correctly stored and retrieved.Constraints:
- 1 <= service_id.length <= 100
- The configuration dictionary size can be at most 10^4 key-value pairs.

In Meta's vast microservices ecosystem, persistent health monitoring is crucial to maintain service reliability and uptime. Your task is to design a class that implements a health monitoring system that tracks various services' health statuses.Problem statement: Define a class HealthMonitor that allows registering services and conducting regular health checks.
- def __init__(self): Initializes the health monitor.
- def register_service(self, service_id: str) -> None: Registers a new service to monitor.
- def health_check(self, service_id: str) -> bool: Conducts a health check and returns the service's health; returns True or False.Example 1:
Input: monitor = HealthMonitor(); monitor.register_service('user_service'); status = monitor.health_check('user_service')
Output: True
Explanation: The user_service is registered and passes the health check.Constraints:
- 1 <= service_id.length <= 100
- Health checks should handle at least 10^5 service registrations.

Meta utilizes microservices architecture where efficient container images are essential for quick deployments. Your task is to optimize a given Dockerfile for a service to reduce build time and image size.Problem statement: Given a suboptimal Dockerfile, improve it by minimizing layer sizes, reducing image bloat, and implementing best practices for performance.
- FROM base_image:latest Base image to start from.
- RUN ... Command that installs dependencies.
- COPY ... Command that copies application code.
- ENTRYPOINT ... Command that defines the startup behavior of the container.Example 1:
Input: Original Dockerfile has unnecessary dependencies and multiple RUN commands.
Output: Optimized Dockerfile reduces layers and improves efficiency.
Explanation: The optimized Dockerfile results in a smaller image with quicker build times.Constraints:
- The Dockerfile must be compatible with Meta's CI/CD pipeline for container deployment.
- Aim for an image size under 100MB.

In Meta's infrastructure, managing Terraform state is critical to ensure deployments are reliable and reproducible. Your task is to implement a minimal Terraform state management system that handles resource states.Problem statement: Write a class TerraformStateManager that keeps track of the state of various resources, allows updates to the state, and can retrieve states efficiently.
- def __init__(self): Initialize the state manager.
- def add_resource(self, resource_id: str, state: Any) -> None: Add or update a resource's state.
- def get_resource(self, resource_id: str) -> Any: Retrieve the state of a specific resource.Example 1:
Input: manager = TerraformStateManager(); manager.add_resource('db_instance', {'status': 'running'}); state = manager.get_resource('db_instance')
Output: {'status': 'running'}
Explanation: The resource 'db_instance' is added and retrieved successfully.Constraints:
- 1 <= resource_id.length <= 100
- The state is any valid JSON compatible Python data structure.
- The resource state should handle at most 10^4 resources.