refactor docker-compose into separate chapter

Author: chendaniely

book/_quarto.yml

@@ -32,6 +32,7 @@ book:
       - lectures/090-conda-lock.qmd
       - lectures/100-containerization-1.qmd
       - lectures/110-containerization-2.qmd
+      - lectures/115-docker-compose.qmd
       - lectures/120-containerization-3.qmd
     - part: parts/data-validation.qmd
       chapters:

book/lectures/110-containerization-2.qmd

@@ -9,7 +9,7 @@ title: Using and running containers
 
 ## Launching containers using Docker at the command line
 
-Docker has many ways we can run containers (GUI, command line, Docker compose configuration files). Here we will learn how to use the command line interface for running container instances from container images. We will then build on this knowledge to move to using Docker compose configuration files for increased efficiency. We are opting to use command line and configuaration file tools so that we can automate and scale the running of containers. It is also more reproducible.
+Docker has many ways we can run containers (GUI, command line, Docker compose configuration files). Here we will learn how to use the command line interface for running container instances from container images. We will then build on this knowledge to move to using Docker compose configuration files for increased efficiency. We are opting to use command line and configuration file tools so that we can automate and scale the running of containers. It is also more reproducible.
 
 Below we demonstrate how to launch and run containers using the [`continuumio/miniconda3` image](https://hub.docker.com/r/continuumio/miniconda3) as an example. We will slowly walk through the 4 basic steps need to run a container:
 
@@ -166,35 +166,6 @@ Another important note is that the container port is specific to the container,
 
 *Source: <https://hub.docker.com/r/rocker/rstudio>*
 
-### Specifying the image architecture/platform
-
-Newer M1 and M2 Macs use a new processor chip, called ARM,
-that is a different architecture compared to the previous
-Macs, and current Windows and Linux machines (which use Intel Processors).
-Given that containerization software virtualizes
-at the level of the operating system user space,
-these different architectures lead to building containers with different architectures.
-
-Also given that Newer M1 and M2 Macs are still the minority of computers
-in use, it is a better practice to work with container architectures that
-work for the majority of in use computers, which are those that have Intel Processors.
-To tell Docker to do this,
-we add the `--platform=linux/amd64` argument to our Docker `run` and `build`
-commands.
-
-To make this process even smoother and less error prone,
-we should also set our Docker Desktop
-to use Rosetta 2 x86/AMD64 emulation on M1/M2 Macs .
-To use this, you must:
-- make sure Rosetta 2 is installed on your Mac (instructions to install it [here](https://support.apple.com/en-ca/HT211861))
-- Select "Use Virtualization framework" and "Use Rosetta for x86/amd64 emulation on Apple Silicon" in the General settings tab of Docker Desktop.
-
-:::{.callout-note}
-- In computer science, emulation works to let you run run software and execute programs originally designed one computer system on another computer system. Emulation is similar to virtualization in concept, but differs from it in that it focuses on enabling software designed for entirely different architectures to be executed.
-- You must also be using macOS Ventura or later to use this feature.
-- You will still need to use the `--platform linux/amd64` command when building or running images even when using Rosetta 2 emulation, because your computer can run and build both `linux/arm64` and `linux/amd64` images. So you have to be clear which architecture you want to work with.
-:::
-
 ### Changing the containers default command
 
 When we launch containers, they execute the command at runtime
@@ -299,8 +270,6 @@ docker run \
     make all
 ```
 
-Note: If you are on a M1/M2 Mac, don't forget to include `--platform=linux/amd64` in your run command.
-
 ## Docker command line commands
 
 The table below summarizes the Docker commands we have learned so far and can serve as a useful reference when we are using Docker:
@@ -327,75 +296,3 @@ The table below summarizes the Docker commands we have learned so far and can se
 | `-v`         | Mounts a volume of your computer to the Docker container |
 | `-p`         | Specifies the ports to map a web app to |
 | `-e`         | Sets environment variables in the container (*e.g.*, PASSWORD="apassword") |
-| `--platform` | Specifies the image architecture, commonly used on M1/M2 Macs to set it to `linux/amd64` |
-
-## Docker compose to launch containers
-
-It can be fiddly and error prone to type long commands into the terminal,
-or a GUI every time you want to launch a container.
-A better approach is to use Docker compose
-to specify how you want to launch the container.
-
-Docker compose uses a YAML file,
-specifically named `docker-compose.yml`,
-to record how the container should be launched.
-This file can include details including:
-- the docker image and version to use
-- how to mount volumes
-- what ports to map
-- what environment variables to set.
-
-Here is an example of a `docker-compose.yml` file
-for use with the `rocker/rstudio` container image:
-
-```yaml
-services:
-  analysis-env:
-    image: rocker/rstudio:4.4.2
-    ports:
-      - "8787:8787"
-    volumes:
-      - .:/home/rstudio/project
-    environment:
-      PASSWORD: password
-```
-
-To launch the container interactively using this file,
-you would type the `docker-compose` command shown below.
-
-```bash
-docker-compose up
-```
-
-If you are using a web app, as in the case of the
-`rocker/rstudio` or `jupyter/minimal-notebook` container images,
-you still need to manually navigate to the web app in your browser
-and enter the correct URL to access it.
-
-To stop and clean up the container, you would type `Cntrl + C` in the terminal where you launched the container, and then type
-
-```bash
-docker-compose rm
-```
-
-Let's take a look at an example `docker-compose.yml` being used in a project:
-- <https://github.com/ttimbers/breast_cancer_predictor_py>
-
-## Running a Docker container non-interactively using the Docker Compose
-
-We can also use Docker Compose to run containers non-interactively!
-We can do this by specifying that we want to `run` the container
-(instead of `up` to launch in interactively).
-We use the `--rm` flag with the `run` command to make the container ephemeral
-(delete it upon exit).
-Then we specify the name of the service from the `docker-compose.yml` file
-that we want to run
-(in our `docker-compose.yml` files so far we only have one service,
-the environment for running the analysis).
-And finally we add the command we want to run non-interactively
-using the container
-(in the example below we use `make` to run the data analysis pipeline script).
-
-```bash
-docker-compose run --rm analysis-env make all
-```

book/lectures/115-docker-compose.qmd

@@ -0,0 +1,75 @@
+---
+title: docker-compose
+---
+
+
+## Docker compose to launch containers
+
+It can be fiddly and error prone to type long commands into the terminal,
+or a GUI every time you want to launch a container.
+A better approach is to use Docker compose
+to specify how you want to launch the container.
+
+Docker compose uses a YAML file,
+specifically named `docker-compose.yml`,
+to record how the container should be launched.
+This file can include details including:
+- the docker image and version to use
+- how to mount volumes
+- what ports to map
+- what environment variables to set.
+
+Here is an example of a `docker-compose.yml` file
+for use with the `rocker/rstudio` container image:
+
+```yaml
+services:
+  analysis-env:
+    image: rocker/rstudio:4.4.2
+    ports:
+      - "8787:8787"
+    volumes:
+      - .:/home/rstudio/project
+    environment:
+      PASSWORD: password
+```
+
+To launch the container interactively using this file,
+you would type the `docker-compose` command shown below.
+
+```bash
+docker-compose up
+```
+
+If you are using a web app, as in the case of the
+`rocker/rstudio` or `jupyter/minimal-notebook` container images,
+you still need to manually navigate to the web app in your browser
+and enter the correct URL to access it.
+
+To stop and clean up the container, you would type `Cntrl + C` in the terminal where you launched the container, and then type
+
+```bash
+docker-compose rm
+```
+
+Let's take a look at an example `docker-compose.yml` being used in a project:
+- <https://github.com/ttimbers/breast_cancer_predictor_py>
+
+## Running a Docker container non-interactively using the Docker Compose
+
+We can also use Docker Compose to run containers non-interactively!
+We can do this by specifying that we want to `run` the container
+(instead of `up` to launch in interactively).
+We use the `--rm` flag with the `run` command to make the container ephemeral
+(delete it upon exit).
+Then we specify the name of the service from the `docker-compose.yml` file
+that we want to run
+(in our `docker-compose.yml` files so far we only have one service,
+the environment for running the analysis).
+And finally we add the command we want to run non-interactively
+using the container
+(in the example below we use `make` to run the data analysis pipeline script).
+
+```bash
+docker-compose run --rm analysis-env make all
+```