Exam 350-901 topic 1 question 84 discussion

I choose A

A: does not make sense as the docker file does not expose the ports. The purpose of the EXPOSE command within the docker file is simply for documentation purposes. The port exposure happens at runtime with the -p argument. https://docs.docker.com/engine/reference/builder/#expose "The EXPOSE instruction does not actually publish the port. It functions as a type of documentation between the person who builds the image and the person who runs the container, about which ports are intended to be published. To actually publish the port when running the container, use the -p flag on docker run to publish and map one or more ports, or the -P flag to publish all exposed ports and map them to high-order ports."

i choose C. rationale: Answer C is specific to a problem with the script. it can't be the build process, the prompt says that it works. it's not the code itself, as the prompt says that the code was reviewed thoroughly. the integration test could fail because the right port wasn't open from the container, but as others have alluded to, the EXPOSE doesn't actually EXPOSE the ports. thus, the one choice that remains is to run the script from the right location.

It seems that during Unit Testing everything is working. But Integration Tests are failing. Therefore it doesn't have the necessary connection to the other components.

the python code normally doesn't manage networking concerns.

In the context of a container running a Python script that fails during the integration testing phase of the CI/CD process, verifying that the necessary modules and packages are installed on build is crucial.

IMO is A unit tests passed so B is out, I would also say C, including reviews (which can be valid for all at the same time) A is because you don't have to use EXPOSE word in Dockerfile, but you can expose the wrong port by starting the app

The build process succeded on this container, so B and D are ruled out. A is ruled out because the container had the correct port exposed on it during standalone testing, so the dockerfile has the port exposed properly. Only C is left

Correct answer is C: To resolve the issue of a container running a Python script failing during the integration testing phase, you should verify option: C. that the script is running from the right directory. Integration tests may depend on the working directory from which the script is executed, and if the script is not running from the correct directory, it can lead to failures. Ensure that the script is executing in the appropriate directory with the necessary files and dependencies available. While the other options may also be important in certain cases, such as checking the exposed port or verifying that the required modules are installed, the issue described in the question is related to script execution and directory context. Therefore, verifying that the script is running from the correct directory is the most relevant action to take in this context

The other options are not as likely to be the cause of the problem. Option A, checking that the correct port is exposed in the Dockerfile, is unlikely to be the cause of the problem because the container is passing unit and integration testing. Option C, checking that the script is running from the right directory, is also unlikely to be the cause of the problem because the code has been reviewed thoroughly. Option D, checking that the Python version of the container image is correct, is also unlikely to be the cause of the problem because all other containers are passing unit and integration testing.

Going with B, the issue is happening in integration testing phase. The script might depend on packages that are not available in build

Correct answer: A Build succeeds. Other answers: build would fail.

I would choose A if the integration phase is being done by another device/software outside of the container and B if it is not. It will depend on how the environment is deployed and the question is not clear about that.

I agree with B as the answer.

pretty much all answers could be right depending on how the integration phase/script/environment was set-up

agree with fechao and endermao, Integration tests are responsible for ensuring that the access to external systems works as expected. Database writes and reads, calls to APIs, and basically every I/O operation your application is performing.

Agreed with fechao, only wrong exposure of ports can lead to a successful build, other choices will make the building failed at first