Google DevOps Engineer Interview Questions

In modern cloud architectures, managing application configurations centrally is critical for consistency and flexibility. Design a ConfigManager class that allows applications to store and retrieve configurations using a key-value pair approach.- class ConfigManager:
- def set_config(self, key: str, value: str) -> None:
Store a configuration value with the associated key.
- def get_config(self, key: str) -> str:
Retrieve the configuration value for the specified key.
- def delete_config(self, key: str) -> None:
Remove the configuration entry.
- def list_configs(self) -> List[Tuple[str, str]]:
Return a list of all configurations as key-value pairs.Example 1:
Input: config_manager = ConfigManager()
config_manager.set_config('feature_x_enabled', 'true')
Output: None
Explanation: Configuration is stored successfully.Constraints:
- 1 <= key.length <= 100
- 1 <= value.length <= 100
- Total number of configurations will not exceed 1000.

In microservices architecture, a Circuit Breaker pattern is used to prevent an application from repeatedly trying to execute operations that are likely to fail. Design a CircuitBreaker class that manages the state of the circuit breaker and the logic to handle requests based on its state.- class CircuitBreaker:
- def call(self, request: Callable[[], T]) -> T:
Executes a request and returns the result or raises an exception if the circuit is open.
- def reset(self) -> None:
Resets the circuit breaker state.Example 1:
Input: cb = CircuitBreaker()
result = cb.call(lambda: my_service_call())
Output: result from my_service_call() or raises an exception
Explanation: The method either returns the result of the service call or throws an exception if the circuit is open.Constraints:
- The circuit contains a specified timeout and threshold for failures.

In order to ensure continuous integration and delivery, it is necessary to design a CI/CD pipeline that automates testing and deployment for various Google services in a scalable manner.
Implement a class CICDPipeline that manages builds and deployments, handles test executions, and keeps track of build histories.- class CICDPipeline:
- def build(self, service_name: str) -> bool:
Returns True if the build is successful, otherwise False.
- def test(self, service_name: str) -> bool:
Returns True if the tests are successful, otherwise False.
- def deploy(self, service_name: str) -> bool:
Returns True if deployment is successful, otherwise False.
- def get_build_history(self) -> List[str]:
Returns a list of build history.Example 1:
Input: pipeline = CICDPipeline()
pipeline.build('ServiceA')
Output: True
Explanation: The build for ServiceA was successful.Constraints:
- 1 <= service_name.length <= 100
- Number of services managed by the pipeline will not exceed 1000.

To optimize the deployment of applications using containerization, it is crucial to enhance the build efficiency of Docker images. This is particularly important for scaling Google services to ensure quicker deployment and reduced resource utilization.
Given a Dockerfile, optimize the instructions to minimize the image size and improve build speed.- def optimize_dockerfile(original: str) -> str:
Return the optimized Dockerfile as a string.Example 1:
Input: FROM python:3.8
RUN apt-get update && apt-get -y install git
COPY . .
RUN pip install -r requirements.txt
Output: FROM python:3.8
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
Explanation: The instructions are reordered to only install packages once.Constraints:
- 1 <= original.length <= 1000
- The Dockerfile syntax will remain valid.