Welcome to ExamTopics
ExamTopics Logo
- Expert Verified, Online, Free.
Mail Us[email protected]
Menu
Google Discussions
exam questions

Exam Professional Cloud Developer All Questions

View all questions & answers for the Professional Cloud Developer exam
Go to Exam

Exam Professional Cloud Developer topic 1 question 119 discussion

Actual exam question from Google's Professional Cloud Developer
Question #: 119
Topic #: 1
[All Professional Cloud Developer Questions]

Your development team has been asked to refactor an existing monolithic application into a set of composable microservices. Which design aspects should you implement for the new application? (Choose two.)

  • A. Develop the microservice code in the same programming language used by the microservice caller.
  • B. Create an API contract agreement between the microservice implementation and microservice caller.
  • C. Require asynchronous communications between all microservice implementations and microservice callers.
  • D. Ensure that sufficient instances of the microservice are running to accommodate the performance requirements.
  • E. Implement a versioning scheme to permit future changes that could be incompatible with the current interface.
Show Suggested Answer Hide Answer
Suggested Answer: B 🗳️
by Blueocean at Jan. 16, 2022, 4:37 a.m.

Comments

Chosen Answer:
This is a voting comment (?). It is better to Upvote an existing comment if you don't have anything to add.
Switch to a voting comment New
Submit Cancel
nqthien041292
Highly Voted 2 years, 7 months ago
Selected Answer: B
Vote BE
upvoted 9 times
...
thewalker
Most Recent 4 months, 1 week ago
Selected Answer: E
The two design aspects you should implement for refactoring a monolithic application into microservices are: B. Create an API contract agreement between the microservice implementation and microservice caller. This is crucial for microservices to communicate effectively. A well-defined API contract ensures that changes to one service don't break other services that depend on it. This promotes independent development and deployment. E. Implement a versioning scheme to permit future changes that could be incompatible with the current interface. Microservices are expected to evolve independently. Versioning allows for backward compatibility and graceful transitions when changes are made to the API. This prevents breaking changes and ensures smooth integration.
upvoted 1 times
thewalker
4 months, 1 week ago
Let's look at why the other options are less critical: A. Develop the microservice code in the same programming language used by the microservice caller. While using the same language can simplify initial development, it's not a strict requirement. Microservices can be written in different languages as long as they adhere to the API contract. C. Require asynchronous communications between all microservice implementations and microservice callers. Asynchronous communication is often beneficial for microservices, but it's not always necessary. Synchronous communication can be appropriate in some cases, especially for tightly coupled services. D. Ensure that sufficient instances of the microservice are running to accommodate the performance requirements. This is important for scaling and performance, but it's more of an operational concern than a design aspect. It's handled through deployment strategies and monitoring.
upvoted 1 times
...
...
alpha_canary
7 months, 2 weeks ago
Selected Answer: B
B & E is the answer
upvoted 2 times
...
__rajan__
1 year, 2 months ago
Selected Answer: B
BD : is the correct one here. Create an API contract agreement between the microservice implementation and microservice caller. This will help to ensure that the microservices are decoupled from each other, and that the caller can be updated without having to update the implementation. Ensure that sufficient instances of the microservice are running to accommodate the performance requirements. This is important because microservices are often scaled independently, and you need to make sure that each microservice can handle the expected load.
upvoted 2 times
...
purushi
1 year, 3 months ago
Selected Answer: E
Versioning schema is the evolutionary process in API development. For eg: /v1/users/1234 /v2/users/1234
upvoted 1 times
...
purushi
1 year, 3 months ago
Selected Answer: B
API contract design is the first step in design-first approach while creating APIs (REST). We can also follow code-first approach while providing solution via public APIs. Design first approach is more flexible and provides sufficient amount of time for the dev team to gather requirements and to understand what customer really wants.
upvoted 1 times
...
edward_zhang
1 year, 9 months ago
D & E， B and E are same thing. D is considering capacity of micro service.
upvoted 1 times
...
omermahgoub
1 year, 10 months ago
Selected Answer: B
B. Guarantees that the two parties are communicating in a well-defined way, which makes the microservices more flexible, composable, and easy to understand. E. Allows to make changes to the service's API while still maintaining backward compatibility. With versioning, new and old consumers can continue to use the service without interruption as new features are added. On the other hand, developing the microservice code in the same programming language as the microservice caller does not promote loose coupling, and it may also increase the complexity of the system as it will depend on language-specific features. Asynchronous communications are also not always necessary and depend on the use case and requirement. Ensuring sufficient instances of the microservice are running can be done by using a scalability strategy such as Auto-scaling, and this is not a specific design aspect.
upvoted 1 times
...
telp
1 year, 10 months ago
BE with the recommendation on https://cloud.google.com/architecture/migrating-a-monolithic-app-to-microservices-gke
upvoted 1 times
...
zellck
1 year, 11 months ago
Selected Answer: B
BE is the answer. https://cloud.google.com/architecture/migrating-a-monolithic-app-to-microservices-gke#api_contracts Each microservice should be invoked only from a set of interfaces. Each interface should in turn be clearly defined by a contract that can be implemented using an API definition language like the OpenAPI Initiative specification or RAML. Having well-defined API contracts and interfaces allows you to develop tests as a main component of your solution (for example, by applying test-driven development) against these API interfaces. https://cloud.google.com/architecture/migrating-a-monolithic-app-to-microservices-gke#versioning To give you flexibility in managing updates that might break existing clients, you should implement a versioning scheme for your microservices. Versioning lets you deploy updated versions of a microservice without affecting the clients that are using an existing version.
upvoted 2 times
...
TNT87
2 years ago
1. When you incrementally migrate services, configure communication between services and monolith to go through well-defined API contracts. Answer B 2. https://cloud.google.com/architecture/microservices-architecture-refactoring-monoliths#design_interservice_communication Ans C Ans B,C
upvoted 1 times
TNT87
2 years ago
To support C https://cloud.google.com/architecture/microservices-architecture-interservice-communication#logical_separation_of_service In this document, you isolate the payment service from the rest of the application. All flows in the original Online Boutique application are synchronous. "In the refactored application, the payment process is converted to an asynchronous flow. Therefore, when you receive a purchase request, instead of processing it immediately, you provide a "request received" confirmation to the user. In the background, an asynchronous request is triggered to the payment service to process the payment."
upvoted 1 times
...
TNT87
2 years ago
To support B *When you incrementally migrate services, configure communication between services and monolith to go through well-defined API contracts. https://cloud.google.com/architecture/microservices-architecture-refactoring-monoliths
upvoted 1 times
...
TNT87
2 years ago
I personally do not see or find anything supporting E at all...
upvoted 1 times
...
...
tomato123
2 years, 3 months ago
Selected Answer: E
BE are correct
upvoted 4 times
...
jdx000
2 years, 4 months ago
Note to admin: change this question's answer to reflect a 2 answer selection
upvoted 4 times
...
jdx000
2 years, 4 months ago
Selected Answer: B
B & E seems best
upvoted 3 times
...
hitmax87
2 years, 7 months ago
B and D
upvoted 2 times
[Removed]
2 years, 6 months ago
For me to ensure that sufficient instances of the microservice are running to accommodate the performance requirements is not needed because of the big variety of services that provide autoscaling. BE
upvoted 1 times
...
...
fabiam93
2 years, 8 months ago
Agree with B and E. https://cloud.google.com/appengine/docs/standard/java/designing-microservice-api#using_strong_contracts
upvoted 2 times
...
GCPCloudArchitectUser
2 years, 9 months ago
This one is tricky one as C and E could be better option as well but there was no mention about reliability…
upvoted 2 times
GCPCloudArchitectUser
2 years, 9 months ago
I will agree with B and E
upvoted 4 times
...
...
Load full discussion...

Get IT Certification

Unlock free, top-quality video courses on ExamTopics with a simple registration. Elevate your learning journey with our expertly curated content. Register now to access a diverse range of educational resources designed for your success. Start learning today with ExamTopics!

Start Learning for free
Community vote distribution
A (35%)
C (25%)
B (20%)
Other
Most Voted
A voting comment increases the vote count for the chosen answer by one.

Upvoting a comment with a selected answer will also increase the vote count towards that answer by one. So if you see a comment that you already agree with, you can upvote it instead of posting a new comment.

SaveCancel