You are developing a new application that has the following design requirements:
✑ Creation and changes to the application infrastructure are versioned and auditable.
✑ The application and deployment infrastructure uses Google-managed services as much as possible.
✑ The application runs on a serverless compute platform.
How should you design the application's architecture?
To meet the design requirements, the architecture should version and audit infrastructure changes, utilize Google-managed services, and run on a serverless compute platform. Using gcloud commands allows for fine control and versioning when combined with a source control system like Git. Cloud Build can be used to define the continuous integration pipeline, which is a Google-managed service. Pulling the application source code from Git and using Cloud Build to create a containerized application that is deployed on Cloud Run meets the serverless compute requirement. Cloud Run is specifically designed for running containerized applications in a serverless environment, providing the necessary versioning and auditing capabilities as it offers revision management.
A is the correct choice. B - use Jenkins as the deployment tool instead of Cloud Build (The application and deployment infrastructure uses Google-managed services as much as possible). C - uses Compute Engine to run containers. CE is not serverless. D - we can't version gcloud commands
Cloud Functions are intended for single-purpose functions, not an entire app. D is a far better fit here and nobody is talking about "versioning gcloud commands" - Cloud Run has revisions (=versions), which meets the task's criteria.
Option D is the best fit for designing the architecture of the new application as it satisfies all the design requirements of versioning and auditing the infrastructure changes, using Google-managed services and deploying the application on a serverless compute platform. The approach includes: - Deploy the application infrastructure using gcloud commands. - Use Cloud Build to define a continuous integration pipeline for changes to the application source code. - Configure a pipeline step to pull the application source code from a Git repository, and create a containerized application. - Deploy the new container on Cloud Run as a pipeline step. It's worth noting that all options could potentially satisfy the requirements, as long as they use Google-managed services and track infrastructure creation and changes, the choice of different services, platform and tools depend on the specific requirements of your application and development preferences.
Option A: 1. Store the application and infrastructure source code in a Git repository. 2. Use Cloud Build to deploy the application infrastructure with Terraform. 3. Deploy the application to a Cloud Function as a pipeline step, can potentially satisfies the requirement of versioning and auditing the infrastructure changes, but it may not meet the other two requirements of using Google-managed services and deploying the application on a serverless compute platform: - By using Terraform, which is a third-party infrastructure as code tool, it is not a Google-managed service and it may not have the same level of integration as Google-managed services. - Cloud Functions are a serverless compute platform, but it's mainly used to run event-driven, short-lived functions, while it's not a suitable choice for running long running processes, web servers and so on.
In addition, deploying the infrastructure using Terraform, which is not fully integrated with the google cloud, may lead to additional cost and management effort. Also, deploying the application on Cloud Functions may not be able to meet some of the requirements like long running processes, stateful workloads and other requirements that Cloud Run can fulfill.
Although, all of the options may have their own merits and depending on the specific requirement of the application any of them can be suitable, but considering all the requirements stated in the question option D could be the best fit.
What about the versioning aspect?
A is correct
I vote D: - gcloud, Cloud Build, Cloud Run - are Google-managed services - Cloud Run has revisions (=versions) - Cloud Run is serverless A is wrong, as Cloud Functions are intended for single-purpose functions - not an entire app.
What put me off A is that at the end there is deploy to ` Cloud Function` and it should be all serverless applications and not just a cloud function, that is what Cloud Run should do.
D would be true if & only it didn't mention using gcloud commands to deploy application infrastructure
My answer is A: Version and auditable: GIT GCP managed deployment infrastructure: Cloud build, Cloud Deployment Manager, Terraform Serverless: Cloud Functions
D is correct, applications should not be deployed on cloud functions.
Vote A
D. 1. Deploy the application infrastructure using gcloud commands. 2. Use Cloud Build to define a continuous integration pipeline for changes to the application source code. 3. Configure a pipeline step to pull the application source code from a Git repository and create a containerized application. 4. Deploy the new container on Cloud Run as a pipeline step. Versioned and Auditable Infrastructure: While Terraform (option A) is a great choice for infrastructure as code, using gcloud commands directly allows for version control and auditing through your Git repository. This ensures a clear history of infrastructure changes. Google-Managed Services: Cloud Build, Cloud Run, and Git repositories are all Google-managed services, fulfilling the requirement for using Google-managed services as much as possible. Serverless Compute: Cloud Run is a serverless platform that perfectly fits the requirement for a serverless compute environment.
Why the other options are less suitable: A. While Terraform is great for infrastructure as code, it's not as directly integrated with Google Cloud's CI/CD tools as gcloud commands. B. Jenkins is a third-party tool, not a Google-managed service. It also doesn't inherently provide the same level of integration with Google Cloud's CI/CD tools as Cloud Build. C. Deployment Manager is a good option for infrastructure as code, but it's not as flexible as gcloud commands for direct control. Also, deploying to a Compute Engine instance doesn't meet the serverless requirement.
Correct answer D based on the requirements
I agree with omermahgoub.
A is correct
It is definitely A vs. B, though. I still think the deciding factor is "Creation and changes to the application infrastructure are versioned and auditable". Whether to deploy to Cloud Run or Cloud Functions is irrelevant because we don't know the contents of the application. Both are serverless.
A is the answer.
Ans A https://cloud.google.com/docs/ci-cd/products#featured-products-for-cicd
B and C are not correct (we cant use jenkins in option B, and cant use compute engine as it is not serverless in option C) So in A and D option - option A is not right becoz we can deploy on cloud function not suitable as serverless compute So i think Answer is D
Changing my answer to A, becoz of versioning. can't use gcloud commands in versioning in option D