docker run -dp 3000:3000 {% raw %}`
     -w /app -v "$(pwd):/app" `
     node:12-alpine `
     sh -c "yarn install && yarn run dev"
```

There is a simple way of doing everything using two files Dockerfile and Docker-compose.yml. These two files will always simplify everything that you are trying to achieve. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7x6h69vvjjh2yult49lg.png)

A Dockerfile is simply a text-based script of instructions that is used to create a container image.

Docker Compose will define all your multi containers from testing, development, and production. 

Before we go back to other components of Docker. Let us discuss these two files because you will generally use them frequently.

#### Dockerfile

Assume you want to start building the above stack backend. We are talking about Node Worker, Redis, Turn Server, and MongoDB. To begin you will need a Mongo Database running, Redis Server running, and Turn Server running. All these can be achieved by either pulling the images from the Docker hub or AWS ECR and building a container or defining everything in a Docker compose file.

#### The structure of a Dockerfile

- Define your environment. If you are working on a node application you need to install node etc. 
- Create a directory where you want to hold all your application files.
- Install all dependencies. To install all our dependencies we need to copy the package.json file.
- Run npm install. 
- Copy all files to the directory you created above.
- Start your application.

*Here is a sample of a dockerfile for development*

```javascript
# install node
FROM node:alpine

# make the 'app' folder the current working directory
WORKDIR /usr/app

# copy both 'package.json' and 'package-lock.json' (if available)
COPY package*.json ./

# install project dependencies
RUN npm install

# copy project files and folders to the current working directory (i.e. 'app' folder)
COPY . .

# serve application in development
CMD [ "npm", "start" ]
```

To build your image ensure you are in the root folder where your Dockerfile resides and run the following command.

```
Docker build .
Docker ps // get the container id or name
Docker run <container id>
```

With the above, you will have your application deployed in a container.

NOTE
Just understand the structure of Dockerfile and what each section defines.


#### Docker compose
Imagine we have many containers to deploy for example we want to deploy Mongo DB, Redis, Turn Server, Vue app. If using the above route of Docker build and Docker run it will quite tedious work. 
Docker-compose simplifies everything.

```javascript
version: "3.8"
services: 
  redis-server:
    container_name: redis-server
    image: redis
    restart: always
  turn-server:
    container_name: turn-server
    image: instrumentisto/coturn
    restart: always
  mongo-server:
    container_name: mongo-server
    image: mongo
    restart: always
  node_backend:
    container_name: node_backend
    build: 
      context: .
      dockerfile: Dockerfile.dev
    restart: always
    depends_on:
      - mongo-server
    environment: 
      - MONGO_DB_URI=mongodb://mongo-server/<db name>
      - REDIS_DB_URI=redis-server
    ports: 
      - 3000:3000
    volumes:
      - ./:/node_backend
```
Once we run the below command all our containers will running and will be under one network. They will be able to communicate with each other.

```
Docker-compose up
```

This will do all the processes we were doing manually one by one. With all containers running you can focus on developing your application. Once you done tear down all your containers.

```
Docker-compose down // shut down your environment
Docker system prune // clean your environment
```

Logging
Run the following commands to see the logging for a container.

```
docker logs -f <container-id>
```

To access a container 

```
docker exec -it <container name> sh
```

Here are some of the common commands your should know while working with image and container

| Command       | 
| ------------- |
| docker run <image>  // build container    | 
| docker ps|
| docker build .   // build an image  | 
| docker rm -f <container/image name> // remove an image  | 
| docker system prune  // clear your enviroment | 
| docker run -dp 8080:8080 <image> //start container port mapping    | 
| docker exec -it <container id/name> command  // get into container   | 
| docker build -t <tagname> .   // tagging a build  | 
| docker scan <container name> | 
| docker image history --no-trunc getting-started |
| docker stop <container name/id>|
| docker kill <container name/id>|
| Docker-compose up|
| Docker-compose down|

I believe the two files I have discussed above will simplify your route of understanding docker containers. Read more about Docker.

https://docs.docker.com/get-docker/

#### How do we go to production?
In general, before we go to production we need to choose which application will we use to manage our containers.

Once you are satisfied with your application structure and all the test have passed then build your image.

We can either use Docker hub or AWS ECR to save your images. For private images, you will be charged for both. Once you have saved your image then you can deploy the containers using Kubernetes, AWS ECR, and AWS ECS. 

The beauty of this architect is that each container will scale independently depending on its load. This means Turn Server might be scalling more than the Redis server. 

# CONCLUSION

The easiest way of installing docker in your machine is through vs-code.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/5s7rihazk4ts7jo8nkcm.png)


This image illustrates a complete environment of docker. 
*image from docker*

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/hr9w5dzdq21nfh9zd03u.png)

Thank you I hope this will be helpful to someone.