= Mounting the configuration file directly into the appropriate pod and container using the
.spec.containers.configMounts key is not a valid way to provide a configuration file to a container at runtime. The .spec.containers.configMounts key does not exist in the Kubernetes API1. The correct way to provide a configuration file to a container at runtime is to use a ConfigMap2. A ConfigMap is a Kubernetes object that stores configuration data as key-value pairs. You can create a ConfigMap from a file, and then mount the ConfigMap as a volume into the pod and container. The configuration file will be available as a file in the specified mount path3. Alternatively, you can also use environment variables to pass configuration data to a container from a ConfigMap4. References:
* PodSpec v1 core
* Configure a Pod to Use a ConfigMap
* Populate a Volume with data stored in a ConfigMap
* Define Container Environment Variables Using ConfigMap Data

Explanation
The --privileged flag lifts all the cgroup limitations for a container, as well as other security restrictions imposed by the Docker daemon1. This gives the container full access to the host's devices, resources, and capabilities, as if it was running directly on the host2. This can be useful for certain use cases that require elevated privileges, such as running Docker-in-Docker or debugging system issues3. However, using the
--privileged flag also poses a security risk, as it exposes the host to potential attacks or damages from the container4. Therefore, it is not recommended to use the --privileged flag unless absolutely necessary, and only with trusted images and containers.
The other options are not correct because they do not lift all the cgroup limitations for a container, but only affect specific aspects of the container's resource allocation or isolation:
*The --cpu-period flag sets the CPU CFS (Completely Fair Scheduler) period for a container, which is the length of a CPU cycle in microseconds. This flag can be used in conjunction with the --cpu-quota flag to limit the CPU time allocated to a container. However, this flag does not affect other cgroup limitations, such as memory, disk, or network.
*The --isolation flag sets the isolation technology for a container, which is the mechanism that separates the container from the host or other containers. This flag is only available on Windows containers, and can be used to choose between process, hyperv, or process-isolated modes. However, this flag does not affect the cgroup limitations for a container, but only the level of isolation from the host or other containers.
*The --cap-drop flag drops one or more Linux capabilities for a container, which are the privileges that a process can use to perform certain actions on the system. This flag can be used to reduce the attack surface of a container by removing unnecessary or dangerous capabilities. However, this flag does not affect the cgroup limitations for a container, but only the capabilities granted to the container by the Docker daemon.
References:
*Runtime privilege and Linux capabilities
*Docker Security: Using Containers Safely in Production
*Docker run reference
*Docker Security: Are Your Containers Tightly Secured to the Ship? SlideShare
*[Secure Engine]
*[Configure a Pod to Use a Limited Amount of CPU]
*[Limit a container's resources]
*[Managing Container Resources]
*[Isolation modes]
*[Windows Container Isolation Modes]
*[Windows Container Version Compatibility]
*[Docker and Linux Containers]
*[Docker Security Cheat Sheet]
*[Docker Security: Using Containers Safely in Production]

Explanation
The networkPolicy will block this traffic. A networkPolicy is a Kubernetes resource that defines how pods are allowed to communicate with each other and with other network endpoints. A networkPolicy has two main sections: podSelector and policyTypes. The podSelector selects which pods the networkPolicy applies to. The policyTypes specifies whether the networkPolicy affects ingress (incoming) traffic, egress (outgoing) traffic, or both. In this case, the networkPolicy applies to pods that have a label app: webserver and affects both ingress and egress traffic. The networkPolicy also has two optional sections: ingress and egress. The ingress section defines the rules for allowing ingress traffic to the selected pods. The egress section defines the rules for allowing egress traffic from the selected pods. If either section is missing or empty, it means that no traffic of that type is allowed. In this case, the networkPolicy has an empty ingress section, which means that no ingress traffic is allowed to the pods that have a label app: webserver. Therefore, a request issued from a pod bearing the tier: backend label, to a pod bearing the tier: frontend label will be blocked by this networkPolicy, since it is an ingress traffic to a pod that has a label app: webserver. References:
https://kubernetes.io/docs/concepts/services-networking/network-policies/,
https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.17/#networkpolicy-v1-networking-k8s-io

Explanation
Adding a new user to the engineering organization in DTR will not automatically grant them read/write access to the engineering/api repository. This is because the repository permissions are not inherited from the organization level, but are configured separately for each repository. Therefore, to grant read/write access to the new user, you need to add them directly to the list of users with read/write access under the repository's Permissions tab. References:
* Docker Trusted Registry - Manage access to repositories
* Docker Certified Associate (DCA) Study Guide - Domain 3: Image Creation, Management, and Registry
https://docs.docker.com/ee/dtr/user/manage-repos/#manage-access-to-repositories
https://success.docker.com/certification/study-guides/dca-study-guide#domain-3-image-creation-management-an