Exam Professional Cloud Architect topic 1 question 22 discussion

C & E: C: Smaller the base image with minimum dependency faster the container will start E: Docker image build uses caching. Docker Instructions sequence matter because application’s dependencies change less frequently than the Python code which will help to reuse the cached layer of dependency and only add new layer for code change for Python Source code.

C & E are the correct answers. Kindly refer - https://www.docker.com/blog/intro-guide-to-dockerfile-best-practices/

CE are correct

A. Remove Python after running pip: This translates to using a multi-stage build. C. Use a slimmed-down base image like Alpine Linux: While the multi-stage build (option A) is the most powerful optimization, you can also change the final stage by using Alpine. A smaller base image means less data to download and store, resulting in faster builds and deployments.

do go against some others here i think B makes more sense that C C wont actually decrease build time as the docker repo should already have the base image downloaded. where as if there are indeed dependancies in requirements.txt that can be removed then B would reduce the build time for the install.

C. Use a slimmed-down base image like Alpine Linux: The ubuntu:16.04 image is a full-fledged operating system, which means it's larger and takes longer to download and build. Alpine Linux is a minimal distribution designed for containers, resulting in significantly smaller images and faster deployments. E. Copy the source after the package dependencies (Python and pip) are installed: Docker builds images in layers. Each RUN, COPY, and ADD instruction creates a new layer. By copying the source code after installing dependencies, you can take advantage of Docker's caching mechanism. If your source code changes, only the layers related to the source code need to be rebuilt, not the layers related to dependencies.

Hi everyone, I have a doubt. The question talks about "deployment" not "build". CE are more correct, in my opinion, to accelerate the build phase (and application management) rather than the simple deployment (with docker swarm, simple docker, kubernetes etc etc)

C&E C - Use small images. E - "Try to make expensive steps appear near the beginning of the Dockerfile. Steps that change often should appear near the end of the Dockerfile" https://docs.docker.com/build/cache/

C is an obvious choice, as an optimized image will be much better for a container than the one in the file. For E, I found an explanation here about COPY that helped me confirm that's the other solution - https://test-dockerrr.readthedocs.io/en/latest/userguide/eng-image/dockerfile_best-practices/#:~:text=required%20files%20change.-,For%20example%3A,-COPY%20requirements.txt.

I know C & E makes the most sense, but the Dockerfile is has a bug. If you don't copy requirements.txt from source, you have nothing to pip install. The line after FROM should be: COPY requirements.txt requirements.txt

The two actions that should be taken to optimize the Dockerfile for faster deployment times without adversely affecting the app's functionality are: B. Remove dependencies from requirements.txt: The requirements.txt file should only contain necessary dependencies to reduce the number of packages to be installed. C. Use a slimmed-down base image like Alpine Linux: The Alpine Linux image is smaller than Ubuntu and has a smaller attack surface, which reduces the container's build time and image size. Therefore, options A, D, and E are not correct as they do not directly address the issue of slow deployment times caused by a bloated Dockerfile.

C: use smaller image decrease pull time E: optimize build time using previous cache layer image. generate new layer only for a different app code and requirements A: can't remove python B: the developer choose right deps D: changing istance type don't directly reduce deploy time

C & E Using a slimmed-down base image like Alpine Linux can help reduce the size of your Docker image, which can lead to faster deployment times. Alpine Linux is a lightweight Linux distribution that is often used as a base image for Docker images because of its small size. Additionally, copying the source code after installing the package dependencies can help reduce the image build time because the dependencies will only need to be installed once, rather than every time the source code is changed. This can lead to faster deployment times because the image build process will be faster.

B & E base image is already cached - so no improvement in build time B is about removing unnecessary dependencies and not about all of them i remember saw this question on google's site - BE are correct

CE and is perfect

C. Use a slimmed-down base image like Alpine Linux E. Copy the source after he package dependencies (Python and pip) are installed

vote C, E https://cloud.google.com/architecture/best-practices-for-building-containers