Cracking Microservices Interview

Learn Advance Concepts, Patterns, Best Practices, NFRs, Frameworks, Tools and DevOps

Sameer S Paradkar

• Publisher: BPB Publications
• Year: 2020
• ISBN:
  9788194334422
• Topic: Computer Science
• Subtopic: Open Source Programming
• Index: Computer Science

Gold mine of microservices interview Questions & Answers for aspirants and domain experts Key Features

• More than 200 questions in 5 domains including a chapter on patterns, practices, and NFRs
• Extended coverage from architecture, design, development to NFRs domains
• The book can be selectively read based on the relevant domains
• Extensive coverage in terms of depth and breadth of domains
• The title has more than 50 diagrams depicting various scenarios, models, and methodologies
• 
  Description
  An SME typically attends several interviews and discussions for jobs or projects during his or her career. There is always a dire need to look up and read multiple books and references before these interviews/discussions so that you stay on top of things. This book will assist software engineers, programmer analysts, designers, consultants, technical, and solution, domain, and enterprise architects to perform well in microservices interview discussions and to launch a successful career. This book also tackles the NFR domain, which is the key aspect to be addressed while creating microservices applications. This book will also assist SMEs to become competent in their respective areas. Usually, it takes a good amount of time to understand the core concepts, fundamentals, patterns, and principles but this book is a gold mine of topics that are typically discussed during a microservices interview. What will you learn
  
• Concepts, principles, and guidelines for various domains for the microservices ecosystem.
• This book presents an exhaustive question bank with special emphasis on practical scenarios and business cases.
• Based on our experience, we assure that at least 80% of the contents will be discussed during a typical interview.
• Common pitfalls to be avoided and patterns to leverage
• Frameworks, methodologies, and design approach leveraged for microservices topologies
• 
  Who this book is for
  This books is for Enterprise Architects, Solution Architects, and Technical Architects/Designers, Project Managers, Programmer Analysts and Software Engineers, Students and Interview Panelists Table of Contents
  1. Introduction
  2. Core Concepts
  3. Advance Concepts
  4. Patterns, Practices and NFRs
  5. Tools and Frameworks
  6. DevOps About the Author
  Sameer Paradkar is an enterprise architect with more than 20 years of solid experience in the ICT industry, which spans across consulting, product development, and systems integration. He is an Open Group TOGAF, Oracle Master Java EA, TMForum NGOSS, IBM SOA Solutions, IBM Cloud Solutions, IBM MobileFirst, ITIL Foundation V3, COBIT 5, and AWS Solution Architect—Associate certified enterprise architect. He serves as an advisory architect on enterprise architecture programs and continues to work as a subject matter expert. He has worked on multiple architecture transformations and modernization engagements (in the USA, UK, Europe, Asia Pacific, and the Middle East Regions) that presented a phased roadmap to the transformation that maximized the business value while minimizing costs and risks.
  Sameer is part of the Architecture Group in AtoS. Prior to AtoS, he has worked in organizations such as EY - IT Advisory, IBM GBS – Application Innovation Services, Wipro Consulting Services – Enterprise Architecture, TechMahindra – Systems and Transformations, and Infosys Technologies – Product Engineering. He specializes in enterprise transformation and modernization engagements.

CHAPTER 1

Introduction

This chapter provides an overview of microservices applications and compares it with the traditional monolithic applications. This chapter then provides the various aspects and benefits that microservices provides to business applications. The subsequent sections deep dives into the microservices application and architecture in further detail.

As the name suggests, the microservices-based architecture is an approach to building business applications as a set of services. Each microservice runs in its own process and communicates with other processes leveraging protocols such as HTTP/HTTPS, AMQP, or web sockets. Each microservice implements a specific vertical domain or business capability within a context boundary and each is developed autonomously and is independently deployable. Finally, each microservice owns its data model and domain logic (decentralized data management and sovereignty) based on various data storage technologies like SQL or NoSQL and various programming languages.

When building a microservice, size should not be a critical point. Instead, the critical point should be to create loosely coupled attributes, so you have autonomy of development, deployment, and scale. When identifying and designing microservices, one should make them as small as possible as long as one does not have many direct dependencies with other microservices. Most important than the size of the microservice is the internal cohesion it should have and its independence from other microservices services.

The microservices architecture provides agility to the businesses or enterprises. Microservices enable enhanced maintainability in large, complex, and highly-scalable systems by enabling creation of applications leveraging many independently deployable services that have autonomous and granular lifecycles.

As an additional benefit, microservices can be scale-out independently. Instead of a single monolithic application requirement to scale out as a one unit, one can instead scale-out specific microservices. This way, one can scale just the functional area that may need more processing power or network bandwidth to support business demand, rather than scaling out other areas of the application that do not need to be scaled. This directly relates to cost saving because of the need for less hardware. The following diagram provides an overview of microservices architecture and its comparision with monolithic architecture:

Figure 1.1: Monolithic vs.microservices

The microservices approach allows agile and rapid iteration of each microservice, as one can change specific, small areas of complex, large, and scalable microservcies applications. Architecting fine-grained microservices-based applications enable continuous integration and continuous delivery processes. This also accelerates delivery of new features and capabilities in the application. Fine-grained composition enables to deploy and test microservices in isolation, and helps to evolve them autonomously while maintaining clear contracts. As long as one does not change the interfaces or contracts, one can change the internal implementation of microservice or add a new functionality without breaking other microservices. The following are the benefits of microservices:

• Separate components: The primary benefit of the microservice architecture is its loosely coupled components. These components can easily be developed, replaced and scaled individually.
• Increased availability and resilience: Microservices improve fault isolation. As complex applications are broken into separate service components and deployed on multiple servers, failing of one of the services or modules will not impact the entire application. A single service fault can easily be replaced with another service (simple to build resilience around the small set of services) increasing the application’s availability.
• Easy to change technology stack: With microservices, software development teams can try a new stack on specific service to avail larger benefits at the application level. There is no long-term commitment to one particular stack as there are no dependency concerns. For example, recommendation micro-services can use python due to its machine-learning libraries against which event-processing micro-services may use Java due to the multithreading properties of JVM.
• Easy to understand even in distributed environment: Understanding how an application is developed is important when there is a change of hand in development teams. In a distributed development project when some of the team members are geographically dispersed, microservice architecture make it easier for dev teams to understand the entire functionality of a service as it is not built into one single package.
• Organized around business capabilities: Microservices are not organized around technical capabilities of a particular product, but rather business capabilities. As the end goal is user experience and customer satisfaction, the teams leveraging microservices are not divided into UI teams, database teams and so on. In fact, there are cross-functional teams that work towards fulfillment of one single functionality. Here’s a diagrammatic representation for quick understanding.
• Re-usability of services: As microservices are organized around business capabilities and not a specific project or product requirement, they are project agnostic. This enables technology teams to reuse services and reduce costs.
• Decentralized data management: Large scale and complex enterprise applications are normally three-tier. Martin Fowler, in his microservices article, describes that microservices let each service manage its own database, either different instances of the same database technology or entirely different database systems. As he mentioned, this approach is called Polyglot Persistence.
• Easy to deploy: While technology teams have to deploy an entire application again because of small change in the code, with microservices this deployment becomes easy. The scope of deployment is smaller and only the service that has a problem needs to be deployed again.

The following important aspects enable success with a microservices-based system:

• Monitoring and healthchecks of the services and infrastructure.
• Scalable infrastructure for the entire landscape via cloud layer, containers, and orchestrators.
• Security at multiple levels: Authentication, authorization, key management, secure communication, cloud layer, application, networks, and more.
• Rapid application delivery of microservices with different teams focusing on different microservices.
• DevOps and CI/CD practices and infrastructure.

Microservices are the newer application platform for cloud native development. Microservices are managed and deployed independently, and once implemented inside containers, they have less interaction with the underlying operating systems. In caseoneis planning to kickstart the career in microservices and would like to build the skills related to it, now is the righttime to dive into when this technology is in its earlystage.

Hence, to help prepare for your interviews, I have come up with microservices interview questions and answers. In the microservices interview questions, I have collected the most frequently asked questions by interviewer’s panels. These questions are collected after consulting with industry experts in the field of microservices and research.

As cloud technology advances its footprint in mission-critical businesses, organizations are increasingly challenging software professionals with creating and maintaining highly available, scalable cloud-based business applications. In response to such challenges, software engineering teams have innovated and developed creative application architectures and business solutions. One of the recent trends in cloud computing is the microservice architecture. This innovative solution involves creating modular, highly scalable, independent, and lowrisk software entitles. This is in an effort to transform and modularize a software solution, increase the availability of cloud-hosted solutions, limit the risk of failures by separating concerns, and avoid bigbang software releases by decoupling dependencies into independent entities. A microservice architecture in practice is simply dividing a business solution into a logically independent unit.

The microservice architecture concept is in stark contrast to traditional monolithic software paradigms, where applications and services are created and delivered as a one whole unified solution. However, the microservice methodology creates value for enterprises by reducing the risk and paving the way for development teams to create and release small independent software units. Each modular software entity created leveraging the microservice architecture would be limited in scope to a function or a single capability and implemented with such goals in mind. In comparison, the traditional monolithic solutions intertwine dependencies and couples business logic with data layers. To clarify this concept, the illustration in Figure 1.1 provides a high-level side-by-side comparison of a microservice architecture against the more traditional monolithic system. The next illustration provides a business services view including the communication protocols in microservices landscape:

Figure 1.2: Microservices architecture

While the terminology around microservices is modern within the software engineering paradigm, the general concept and goals surrounding the microservice architecture have been around for quite sometime. Earlier, incarnations of microservices were aptly titled service-oriented architecture (SOA). However, the term SOA was too broad in scope and specific implementation strategies were vague. As such, organizations struggled to implement SOA-based solutions effectively.

In summary, unlike monolithic architecture, microservices are project-agnostic providing business capabilities instead of functionality specific to a particular project. This makes them reusable thereby reducing cost of ownership. Moreover, scaling up of individual services is much easier with microservice architecture than monolithic architecture. This is mainly because each service could be individually developed, replaced and scaled as needed. In monolithic architecture, it is not possible to scale in real time as all the functionalities are bundled together in one single artifact.

With more and more product companies now resorting to iterative development, it is crucial to have an underlying architecture which is robust, scalable and easily adaptable to real-time business needs. Microservices are surely the game changer. They not only improve the experience of development teams about building and understanding application but also improve the overall user experience. Being able to improve fault isolation, even when one of the services fail, the application is still available to users which ensure a break free experience.

The next chapters that follow will include the question bank for all the key domains that are covered in the book. The microservices domain covered in the book includes core concepts, advance concepts, patterns, practices and NFRs, tools andframeworks and DevOps. The next chapters will present an exhaustive question bank with special emphasis on practical scenarios and business cases.

CHAPTER 2

Core Concepts

This is the core chapter that provides the question bank for the core concepts domain. This chapter presents an exhaustive question bank with special emphasis on practical scenarios and business cases.

1. What are microservices?
   Microservices is a variation of service-oriented architecture (SOA) style that organizes a business application as a collection of loosely coupled services. In a microservices architecture paradigm, services are fine-grained and leverage light-weight protocols such as REST over SOAP. The benefit of segregating a business application into smaller services is that it enhances the modularity and makes the application easier to develop, test, and maintain. Development effort is parallelized by enabling small autonomous teams to develop, deploy, test, and scale their services independently. Microservices also allows the architecture of an individual service to evolve through continuous refactoring. Microservices-based architectures enable continuous integration and continuous delivery.
   In the microservice paradigm, teams develop a single, small, and meaningful functional feature as a single service and each service has its own process and communicates leveraging a lightweight mechanism deployed on single or multiple servers. In the microservice architectural style, a business application is structured as a collection of self-contained, loosely coupled services. Teams can create microservices in several different languages, including Java, Scala, Node.js, and more.
   The following are the similarities of microservices and SOA services:
   • Microservices are reusable and can be invoked from desktop applications, web applications, and mobile applications, or by other microservices.
   • Microservices are loosely coupled and interact with each other through lightweight mechanism; for example, REST, JSON, XML, and more
   • WADL, JSON Schema, or Swagger is leveraged for describing the microservices.
   The following are the difference between microservices and SOA services:
   • Microservices typically don’t rely on enterprise products like Enterprise Service Bus (ESB).
   • There are no physical infrastructure dependencies with microservices. They are usually deployed in Docker containers, which encapsulate both the code and required libraries.
2. Describe the microservices architecture.
   The microservices architecture allows you to avoid monolith applications for large systems. It provides loose coupling between collaborating processes that run independently in different environments with tight cohesion. The microservice architecture is an architectural style that builds an application as a collection of small autonomous services developed for a specific business domain. The microservice architecture consists of small, independent, self-contained services that implement a single business capability or function. The following diagram represents the microservice architecture:

   

   Figure 2.1: Microservices reference architecture
   The microservices reference architecture consists of the following:
   • Client: The client can be a web application, desktop application, mobile application, or even another remote microservice.
   • API Gateway: The API gateway handles client requests and forwards them to the appropriate service.
   • Microservices: These are small, independent, and loosely coupled microservi...