mikeconrad/demystifying-docker-previous
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2025-06-11. You can view files and clone it, but cannot push or open issues or pull requests.
Files
a2e5374abaf143bd82c6087fc40b10f4f3d034f6
demystifying-docker-previous/slides.md
Mike Conrad a2e5374aba Add more slides
2025-04-30 19:23:10 -04:00

10 KiB
Raw Blame History

theme, background, title, info, class, drawings, transition, mdc
theme background title info class drawings transition mdc
seriph https://cover.sli.dev Welcome to Slidev ## Slidev Starter Template Presentation slides for developers. Learn more at [Sli.dev](https://sli.dev) text-center
persist
false
slide-left true

Demystifying Docker

A beginners guide to containerization and beyond

Press Space for next page

transition: fade-out

Who am I?

Mike Conrad

  • 📝 Text-based - focus on the content with Markdown, and then style them later
  • 🎨 Themable - themes can be shared and re-used as npm packages
  • 🧑‍💻 Developer Friendly - code highlighting, live coding with autocompletion
  • 🤹 Interactive - embed Vue components to enhance your expressions
  • 🎥 Recording - built-in recording and camera view
  • 📤 Portable - export to PDF, PPTX, PNGs, or even a hostable SPA
  • 🛠 Hackable - virtually anything that's possible on a webpage is possible in Slidev

Read more about Why Slidev?

<style> h1 { background-color: #2B90B6; background-image: linear-gradient(45deg, #4EC5D4 10%, #146b8c 20%); background-size: 100%; -webkit-background-clip: text; -moz-background-clip: text; -webkit-text-fill-color: transparent; -moz-text-fill-color: transparent; } </style>

transition: slide-up layout: quote level: 2

What is a container?

A method for packaging and securely running an application within an application virtualization environment. Also known as an application container or a server application container. NIST

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings. Docker

layout: two-cols layoutClass: gap-16

Problems?

  • 📝 It works on my machine?!?! - Code behaves differently in dev, testing, and production due to differences in environment (OS, dependencies, configurations).
  • 🎨 Dependency conflicts - Different applications require conflicting versions of the same dependency (e.g., Python 2 vs 3, different Node versions).
  • 🧑‍💻 Slow and error-prone deployments - Traditional deployments involve manual steps or configuration drift between environments.

::right::

Solutions

  • Containers package the application and its dependencies in a consistent, isolated environment, ensuring it behaves the same everywhere.
  • Containers isolate applications and their dependencies from each other and the host system, preventing conflicts.
  • Containers provide predictable, repeatable, and scriptable deployments through container images.

transition: slide-right layout: two-cols layoutClass: gap-16

Problems?

  • 📝 Inefficient resource usage in virtual machines (VMs) - VMs have high overhead due to running full operating systems, leading to inefficiency.
  • 🎨 Difficult scalability and orchestration - Scaling applications manually is hard and error-prone.
  • 🧑‍💻 Inconsistent development workflows - devs all have different setups, leading to inconsistent builds and bugs.

::right::

Solutions

  • Containers share the host OS kernel and are more lightweight, enabling faster startup and denser packing of applications.
  • Containers integrate well with orchestrators (like Kubernetes), enabling automated scaling, rolling updates, and fault tolerance.
  • Containers standardize development environments using tools like Docker Compose or dev containers.

transition: fade-out layout: two-cols-header title: Differences between VM and Container?

Differences between VM and Containers?

::left::

Virtual Machine

  • Virtualizes hardware
  • Runs a full guest OS (e.g., Linux or Windows)
  • Heavier: includes the OS, libraries, and application
  • Slow to start, uses more resources

Example: Running Ubuntu with Apache inside a VM on a Windows host

::right::

Container

  • Virtualizes at the OS level
  • Shares the host OS kernel
  • Isolates only the application and its dependencies
  • Lightweight: faster startup, lower resource use

Example: Running a Node.js app in a container using the host's Linux kernel

transition: fade-out

How do they work?

Containers are just processes

If you don't take anything else away from this talk, I hope you walk away with a better understanding of this fundamental. As far as the OS* is concerned, a container is just another process/set of processes to the operating system.








*This is only strictly true on Linux. Running Docker on Mac/Windows requires Docker Desktop which actually creates and manages a Linux VM. Your containers actually run inside of this VM.

--- transition: fade-out layout: two-cols-header --- # Let's get started

::left::

Windows/Mac

Install Docker Desktop from: https://docs.docker.com/desktop/

::right::

Linux

Find installation instructions for Docker Engine here: https://docs.docker.com/engine/install/ubuntu/

transition: fade-out

Running our first container

First run the container

We are running an nginx webserver container in daemon (background mode). We are forwarding connections from localhost:8088 to port 80 inside the container. This is the default port that nginx is running on.

```shell
$ docker run --rm -p 8088:80 --name nginx-container -d nginx:alpine
```
```shell
$ docker run --rm -p 8088:80 --name nginx-container -d nginx:alpine
cd4302edce965beb95fdb9ecb19ff7432758f1e505d792e368fd401ea9abab65
```
```shell
$ docker container ps
```
```shell
$ docker container ps
CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                                     NAMES
cd4302edce96   nginx:alpine   "/docker-entrypoint.…"   15 seconds ago   Up 14 seconds   0.0.0.0:8088->80/tcp, [::]:8088->80/tcp   nginx-container
```

Now run docker container ps to list running containers


--- transition: fade-out ---

View the logs for our container


```shell
$ docker container logs --follow nginx-container 
```


```shell
$ docker container logs --follow nginx-container 
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/04/30 23:02:32 [notice] 1#1: using the "epoll" event method
2025/04/30 23:02:32 [notice] 1#1: nginx/1.27.5
2025/04/30 23:02:32 [notice] 1#1: built by gcc 14.2.0 (Alpine 14.2.0) 
2025/04/30 23:02:32 [notice] 1#1: OS: Linux 6.12.10-76061203-generic
2025/04/30 23:02:32 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1024:524288
2025/04/30 23:02:32 [notice] 1#1: start worker processes
2025/04/30 23:02:32 [notice] 1#1: start worker process 30
2025/04/30 23:02:32 [notice] 1#1: start worker process 31
2025/04/30 23:02:32 [notice] 1#1: start worker process 32
2025/04/30 23:02:32 [notice] 1#1: start worker process 33
2025/04/30 23:02:32 [notice] 1#1: start worker process 34
2025/04/30 23:02:32 [notice] 1#1: start worker process 35
2025/04/30 23:02:32 [notice] 1#1: start worker process 36
2025/04/30 23:02:32 [notice] 1#1: start worker process 37

```

transition: fade-out

Interacting with our container

Now let's try interacting with the Nginx server. By default it should serve a default page.


```shell
# Hitting Ctrl+Z on Linux will put our logs process into the background

$ ^Z
```
```shell
$ ^Z

[1]+  Stopped                 docker container logs --follow nginx-container
```
```shell
# Now send a curl request to localhost:8080.  This should be forwarded to port 80 in our container
$ curl localhost:8088
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>
```