instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from a device (format: <device-path>:<number>). Number is a positive integer.--device-write-iops=""Limit write rate (IO per second) to a device (format: <device-path>:<number>). Number is a positive integer.--oom-kill-disable=falseWhether to disable OOM Killer for the container or not.--oom-score-adj=0Tune container's OOM preferences (-1000 to 1000)--memory-swappiness=""Tune a container's memory swappiness behavior. Accepts an integer between 0 and 100.--shm-size=""Size of /dev/shm. The format is <number><unit>. number must be greater than 0. Unit is optional and can be b (bytes), k (kilobytes), m (megabytes), or g (gigabytes). If you omit the unit, the system uses bytes. If you omit the size entirely, the system uses 64m.User memory constraintsWe have four ways to set user memory usage:OptionResultmemory=inf, memory-swap=inf (default)There is no memory limit for the container. The container can use
  as much memory as needed.memory=L<inf, memory-swap=inf(specify memory and set memory-swap as -1) The container is
  not allowed to use more than L bytes of memory, but can use as much swap
  as is needed (if the host supports swap memory).memory=L<inf, memory-swap=2*L(specify memory without memory-swap) The container is not allowed to
  use more than L bytes of memory, swap plus memory usage is double
  of that.memory=L<inf, memory-swap=S<inf, L<=S(specify both memory and memory-swap) The container is not allowed to
  use more than L bytes of memory, swap plus memory usage is limited
  by S.Examples:
  
  $ docker run -it ubuntu:24.04 /bin/bash
  We set nothing about memory, this means the processes in the container can use
  as much memory and swap memory as they need.
  
  $ docker run -it -m 300M --memory-swap -1 ubuntu:24.04 /bin/bash
  We set memory limit and disabled swap memory limit, this means the processes in
  the container can use 300M memory and as much swap memory as they need (if the
  host supports swap memory).
  
  $ docker run -it -m 300M ubuntu:24.04 /bin/bash
  We set memory limit only, this means the processes in the container can use
  300M memory and 300M swap memory, by default, the total virtual memory size
  (--memory-swap) will be set as double of memory, in this case, memory + swap
  would be 2*300M, so processes can use 300M swap memory as well.
  
  $ docker run -it -m 300M --memory-swap 1G ubuntu:24.04 /bin/bash
  We set both memory and swap memory, so the processes in the container can use
  300M memory and 700M swap memory.Memory reservation is a kind of memory soft limit that allows for greater
  sharing of memory. Under normal circumstances, containers can use as much of
  the memory as needed and are constrained only by the hard limits set with the
  -m/--memory option. When memory reservation is set, Docker detects memory
  contention or low memory and forces containers to restrict their consumption to
  a reservation limit.Always set the memory reservation value below the hard limit, otherwise the hard
  limit takes precedence. A reservation of 0 is the same as setting no
  reservation. By default (without reservation set), memory reservation is the
  same as the hard memory limit.Memory reservation is a soft-limit feature and does not guarantee the limit
  won't be exceeded. Instead, the feature attempts to ensure that, when memory is
  heavily contended for, memory is allocated based on the reservation hints/setup.The following example limits the memory (-m) to 500M and sets the memory
  reservation to 200M.
  
  $ docker run -it -m 500M --memory-reservation 200M ubuntu:24.04 /bin/bash
  Under this configuration, when the container consumes memory more than 200M and
  less than 500M, the next system memory reclaim attempts to shrink container
  memory below 200M.The following example set memory reservation to 1G without a hard memory limit.
  
  $ docker run -it --memory-reservation 1G ubuntu:24.04 /bin/bash
  The container can use as much memory as it needs. The memory reservation setting
  ensures the container doesn't consume too much memory for long time, because
  every memory reclaim shrinks the container's consumption to the reservation.By default, kernel kills processes in a container if an out-of-memory (OOM)
  error occurs. To change this behaviour, use the --oom-kill-disable option.
  Only disable the OOM killer on containers where you have also set the
  -m/--memory option. If the -m flag is not set, this can result in the host
  running out of memory and require killing the host's system processes to free
  memory.The following example limits the memory to 100M and disables the OOM killer for
  this container:
  
  $ docker run -it -m 100M --oom-kill-disable ubuntu:24.04 /bin/bash
  The following example, illustrates a dangerous way to use the flag:
  
  $ docker run -it --oom-kill-disable ubuntu:24.04 /bin/bash
  The container has unlimited memory which can cause the host to run out memory
  and require killing system processes to free memory. The --oom-score-adj
  parameter can be changed to select the priority of which containers will
  be killed when the system is out of memory, with negative scores making them
  less likely to be killed, and positive scores more likely.Kernel memory constraintsKernel memory is fundamentally different than user memory as kernel memory can't
  be swapped out. The inability to swap makes it possible for the container to
  block system services by consuming too much kernel memory. Kernel memory includesï¼stack pagesslab pagessockets memory pressuretcp memory pressureYou can setup kernel memory limit to constrain these kinds of memory. For example,
  every process consumes some stack pages. By limiting kernel memory, you can
  prevent new processes
  ```