Explanation
The command docker run --log-driver=splunk for every container at run time will configure a Docker container to export container logs to the logging solution. The reason is that the --log-driver option specifies the logging driver for the container, which determines how the container logs are handled1. The splunk logging driver is a plugin that sends container logs to HTTP Event Collector in Splunk Enterprise and Splunk Cloud2. To use the splunk logging driver, you also need to provide some additional options with the --log-opt flag, such as the Splunk token, URL, source, sourcetype, index, etc2. For example, to run a container with the splunk logging driver and send the logs to a Splunk instance with the URL https://splunk.example.com:8088 and the token 176fabb6-7811-4b3a-8ba0-4d49302e50f2, you can use:
docker run --log-driver=splunk --log-opt splunk-token=176fabb6-7811-4b3a-8ba0-4d49302e50f2 --log-opt splunk-url=https://splunk.example.com:8088 ...
This way, you can configure a Docker container to export container logs to Splunk, which is a centralized logging solution. Alternatively, you can also configure the splunk logging driver as the default logging driver for the Docker daemon by setting the log-driver and log-opts keys in the daemon.json file and restarting Docker3. This will apply the splunk logging driver to all containers unless overridden by the --log-driver option. References:
* Configure logging drivers
* Splunk logging driver
* Set the logging driver for the Docker daemon

Explanation
This
statement is correct about this health check definition. A health check is a feature that allows Docker to monitor the health status of a container by running a command in the container periodically. A health check has three parameters: test, interval, and retries. The test parameter specifies the command to run to check the health of the container. The interval parameter specifies how often to run the health check. The retries parameter specifies how many consecutive failures of the health check are needed to mark the container as unhealthy. In this case, the health check runs curl -f http://localhost/ || exit 1 every 10 seconds to test for app health. If this command fails three times in a row, the container is marked as unhealthy. References:
https://docs.docker.com/engine/reference/builder/#healthcheck,
https://docs.docker.com/engine/reference/run/#healthcheck

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
n: = Using the DTR web UI to make all tags in the repository immutable is not a good way to prevent an image, such as 'nginx:latest', from being overwritten by another user with push access to the repository. This is because making all tags immutable would prevent any updates to the images in the repository, which may not be desirable for some use cases. For example, if a user wants to push a new version of 'nginx:latest' with a security patch, they would not be able to do so if the tag is immutable. A better way to prevent an image from being overwritten by another user is to use the DTR webUI to create a promotion policy that restricts who can push to a specific tag or repository1. Alternatively, the user can also use the DTR API to create a webhook that triggers a custom action when an image is pushed to a repository2. References:
* Prevent tags from being overwritten | Docker Docs
* Create webhooks | Docker Docs