instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from being created when the kernel memory usage is too high.Kernel memory is never completely independent of user memory. Instead, you limit
  kernel memory in the context of the user memory limit. Assume "U" is the user memory
  limit and "K" the kernel limit. There are three possible ways to set limits:OptionResultU != 0, K = inf (default)This is the standard memory limitation mechanism already present before using
  kernel memory. Kernel memory is completely ignored.U != 0, K < UKernel memory is a subset of the user memory. This setup is useful in
  deployments where the total amount of memory per-cgroup is overcommitted.
  Overcommitting kernel memory limits is definitely not recommended, since the
  box can still run out of non-reclaimable memory.
  In this case, you can configure K so that the sum of all groups is
  never greater than the total memory. Then, freely set U at the expense of
  the system's service quality.U != 0, K > USince kernel memory charges are also fed to the user counter and reclamation
  is triggered for the container for both kinds of memory. This configuration
  gives the admin a unified view of memory. It is also useful for people
  who just want to track kernel memory usage.Examples:
  
  $ docker run -it -m 500M --kernel-memory 50M ubuntu:24.04 /bin/bash
  We set memory and kernel memory, so the processes in the container can use
  500M memory in total, in this 500M memory, it can be 50M kernel memory tops.
  
  $ docker run -it --kernel-memory 50M ubuntu:24.04 /bin/bash
  We set kernel memory without -m, so the processes in the container can
  use as much memory as they want, but they can only use 50M kernel memory.Swappiness constraintBy default, a container's kernel can swap out a percentage of anonymous pages.
  To set this percentage for a container, specify a --memory-swappiness value
  between 0 and 100. A value of 0 turns off anonymous page swapping. A value of
  100 sets all anonymous pages as swappable. By default, if you are not using
  --memory-swappiness, memory swappiness value will be inherited
  ```