[For Linux: add 'sudo' before all the commands]
1.image:
a lightweight, stand-alone, executable package that includes everything needed to run a piece of software , including the code, a runtime, libraries, environnement variables, and config files.
2. container:
- a runtime instance of image
- what the image becomes in memory when actually executed
- runs completely isolated from the host environnement by default
- only access host files and ports
3. begin building an app the Docker way:
Stack:
at the top level, define the interactions of all the services
Service:
defines how containers behave in production
Container:
at the bottom of the hierarchy of such an app executed images
3.1Dockerfile:
Define a container with a Dockerfile :
#use an official Python runtime as a base image
FROM python:2.7-slim
#Set the working directory to /app
WORKDIR /app
#Copy the current directory contents into the container at /app
ADD . /app
#Install any needed packages specified in requirements.txt
RUN pip install -r requirements.txt
#Make port 80 available to the world outside this container
EXPOSE 80
#Define environnement variable
ENV NAME World
#Run app.py when the container launches
CMD ["python", "app.py"]
3.2 Build the app
- ls
Dockerfile app.py requirements.txt
docker build -t friendlyhello .
* the build command
* this creates a Docker image called "friendlyhello" from the current directory
* tag this created image by "-t"
docker images
Where's your built images? in your machine's local Docker image registry
3.3 Run the app
- run the app, map your machine's port 4000 to the container's exposed port 80 using "-p" :
docker run -p 4000:80 friendlyhello
- http://0.0.0.0:80 : coming from inside the container
- http:// localhost:4000 : the correct URL
- run in detached mode :
docker run -d -p 4000:80 friendlyhello
- see the abbreviatedcontainer IDwith
docker ps
- to end the process, using theCONTAINER ID:
docker stop 1fa4ab2cf395
3.4 Share your image:
- Object :
* upload our build
* run it somewhere else
* learn how to push to registries to make deployment of containers actually happen
- Registry :
* a collection of repositories
- Repository :
* a collection of images
* like a Github repository
* except the code is already built
- An account on a repository : cloud.docker.com
- STEPS :
* docker login
* docker tag friendlyhello username/repository:tag
* docker push username/repository:tag
* docker run -p 4000:80 username/repository:tag
4. Services
- learn how to scale your application by running this container in a service & enable load-balancing
- Prerequisites :
* docker run -p 80:80 username/repo:tag
* ensure your image is working by running this and visiting http://localhost
- Service :
In a distributed application, different pieces of app are called "Services"
For example, a video sharing site:
* a service for storing application data in db
* a service for video transcoding in the background
* a service for the front-end
"Services : containers in production"
A service :
* only runs an image
* codifies the way that images run :
-> what ports it should use
-> how many replicas of the container should run so the service has the capability it needs
*Scaling a service changes the number of containers instances running that piece of software
4.1 define, run and scale services with the Docker platform with file :
docker-compose.yml
a YAML file that defines how docker containers should behave in production
Docker-compose.yml
version: "3"
services:
web:
images: username/repository:tag
deploy:
replicas: 5
resources:
limits:
cpus: "0.1"
memory: 50M
restart_policy:
condition: on-failure
ports:
- "80:80"
networks:
- webnet
networks:
webnet
* replicas: 5
Run 5 instances of the images we uploaded as a service called web
* condition: on-failure
immediately restart containers if one fails
* "80:80"
the 1st 80 means the port on the host
* the 1st "networks: - webnet "
instruct web's containers to share port 80via a load-balanced network called webnet
* the 2nd "networks: -webnet"
define the webnet network with the default settings (which is aload-balancing overlay network)
4.2 Run your new load-balanced app
STEP 01
docker swarm init
STEP 02
docker stack deploy -c docker-compose.yml getstarted
(give your app a name getstarted)
STEP 03
docker stack ps getstarted
(see a list of five containers you just launched)
STEP 04
curl http://localhost/
4.3 Scale the app
scale the app by changing the replicas values in docker-compose.yml, saving the change, and re-running the "docker stack deploy" command :
docker stack deploy -c docker-compose.yml getstarted
4.4 Take down the app
docker stack rm getstarted
5. Swarm
* In part Services:
- take an app you wrote
* In part Containers
- define how it should run in production by turning it to a service
- scaling it up 5 x in the process
* In part Swarm:
- deploy this application onto a cluster
- running it on multiple machines
*Multi-container, multi-machine applications are made possible by joining multiple machines into a"dockerized" cluster called a
swarm
* A swarm:
a group of machines that are running Docker and have been joined into a cluster
* run the Docker commands, these commands run on a cluster by a
swarm manager
* Swarm manager:
use strategy to run containers:
-"emptiest mode": which fills the least utilised machines with containers
-"global": which ensures that each machine gets exactly one instance of the specified container
instruct swarm manager to use these strategies in the compose file
* the only machine in a swarm to:
- execute your commands
- authorise other machines to join the swarm as workers
* Worker:
- just provide capacity
- do not have the authority to tell any other machine what it can or cannot do
* Swarm mode:
- Docker work mode:
*a single-host mode on your local machine
* swarm mode
- swarm mode:
* Enabling swarm mode instantly makes the current machine a swarm manager
* Docker executes commands on the swarm, rather than on the current machine.
5.1 Set up your swarm:
- A swarm is made up of multiple nodes, which can be either physical or virtual machines.
- basic concepts:
docker swarm init
to enable swarm node and make your current machine a swarm manager
docker swarm join
(on other machines)
to have them join the swarm as a worker
5.2 Create a cluster
- create a couple of Vos using the Virtualbox driver :
docker-machine
docker-machine create --driver virtualbox myvm1
docker-machine create --driver virtualbox myvm2
(myvm1 - manager; myvm2 - worker)
- send commands to your VMs using
docker-machine ssh
docker-machine ssh myvm1 "docker swarm init"
("docker swarm init" - instruct myvm1 to become a swarm manager)
- to have myvm2 join your new swarm as a worker:
docker-machine ssh myvm2 "docker swarm join --token :"
5.3 Deploy your app on a cluster
- deploy your app on your new swarm
- only swarm manager like myvm1 can execute commands
- workers are just for capacity
- copy the docker-compose file to the swarm manager myvm1 home directory (alias: ~)
docker-machine sap docker-compose.yml myvm1:~
- Now that myvm1 use its powers as a swarm manager to deploy your app
docker-machine ssh myvm1 "docker stack deploy -c docker-compose.yml getstartedlab"
the app is deployed on a cluster
- you'll see the containers have been distributed between both myvm1 and myvm2
docker-machine ssh myvm1 "docker stack ps getstartedlab"
5.4 Accessing your cluster
- To get your VMs' IP addresses
docker-machine ls
- visit either of them on a browser
6. Stack
Swarm Chapitre:
- learn how to set up a swarm
* a swarm: a cluster of machines running Docker
- and deploy an app on a swarm, with containers running in concert on multiple machines
Stack Chapitre:
- A stack:
* the top of the hierarchy of distributed app
*a group of integrated services that share dependencies, and can be orchestrated and scaled together
-A single stack is capable of defining and coordination the functionality of an entire application
- In part Swarm: a single stack of a single service runs on a single host
- In part Stack: a stack of multiple services related to each other and run them on multiple machines
实际操作过程总结
1. /images/php7_fpm_base: {php7_fpm_base}
* docker build -t bonjourausy_php7_fpm_base .
* docker tag bonjourausy_php7_fpm_base $DOCKER_ID_USER/bonjourausy_php7_fpm_base
* docker push $DOCKER_ID_USER/bonjourausy_php7_fpm_base
* docker images
- php: 7-fpm
- bonjourausy_php7_fpm_base:latest
- amelieykw/bonjourausy_php7_fpm_base:latest
2. /images/app: {app}
* docker build -t bonjourausy_app .
* docker tag bonjourausy_app $DOCKER_ID_USER/bonjourausy_app
* docker push $DOCKER_ID_USER/bonjourausy_app
* docker images
- bonjourausy_app : latest
- amelieykw/bonjourausy_app : latest
3. /images/nginx: {webnginx}
* docker build -t bonjourausy_webnginx .
* docker tag bonjourausy_webnginx $DOCKER_ID_USER/bonjourausy_webnginx
* docker push $DOCKER_ID_USER/bonjourausy_webnginx
* docker images
- nginx: latest
- bonjourausy_webnginx: latest
- amelieykw/bonjourausy_webnginx: latest
4. /images/mysql: {mysql}
* docker build -t bonjourausy_mysql .
* docker tag bonjourausy_mysql $DOCKER_ID_USER/bonjourausy_mysql
* docker push $DOCKER_ID_USER/bonjourausy_mysql
* docker images
- mysql: latest
- bonjourausy_mysql: latest
- amelieykw/bonjourausy_mysql: latest
Docker Compose VS Docker Cloud Stack File
1. Docker Compose
* Docker compose runs on localhost or virtual machine
* Prerequistes:
- already install Docker Engine or Docker Compose
* STEP 01: Set Up
- mkdir composetest
- cd composetest
- create a file of app code (like app.py) in this directory
* STEP 02: Create a Dockerfile
-Dockerfile: to build an image
- create a Dockerfile in the directory of the image
- Dockerfile: to tell all the dependencies that this image needs
FROM python: 3.4-alpine
# Build an image starting with the python 3.4 image
ADD . /code
# Add the current directory into the path /code in the image
WORKDIR /code
# Set the working directory to /code
RUN pip install -r requirements.txt
# install the Python dependencies
CMD ["python", "app.py"]
# Set the default command for the container to "python app.py"
requirements.txt
flask
redis
* STEP 03: Define services in a Compose file
docker-compose.yml
version: '2'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- . : /code
redis:
image: "redis : alpine"
-build: .
use an image that's build from the Dockerfile in the current directory
-ports: - "5000:5000"
the 1st port 5000 on the host machine
the 2nd port exposed port 5000 on the container
-. : /code
Mounts the project directory on the host to /code inside the container, allowing you to modify the code without having to rebuild the image
* STEP 04: Build and run your app with Compose
docker-compose up -d
- Linux host machine: http://loaclhost:5000
Mac docker machine: http://MACHINE_VM_IP:5000
docker-machine ip MACHINE_VM
- list local images:
docker image ls
- inspect local images:
docker inspect
* STEP 05: Update the application
- Because the application code is mounted into the container using a volume, you can make changes to its code and see the changes instantly, without having to rebuild the image.
- STEPs:
* change the app code in app.py
* refresh the browser to see the changes
* STEP 06: Expriment with some other commands
docker-compose up -d
run your services in the background in the "detached" mode
docker-compose ps
to see what is currently running
docker-compose run web env
allows to run one-off commands for your service
docker-compose stop
to stop your services once you've finished with them
docker-compose down --volumes
to bring everything down, removing the containers entirely, with the down command
--volumes
remove the data volumes used by the Redis container
docker-compose --help
2. Stack file for Docker Cloud
*A stack: a collection of services that make up an application
*A stack file:
- a file in YAML format that defines one or more services
- similar to docker-compose.yml file for Docker Compose
- but a few extensions
- default name:
docker-cloud.yml
* Manage service stacks:
-Stacks:
a convient way to automatically deploy multiple services that are linked to each other, without needing to define each one separately
-Stack files:
define :
* environnement variables
* deployment tags
* the number of containers
* related environnement-specific config
docker-cloud.yml
lb:
image: dockercloud/haproxy
links:
- web
ports:
- "80:80"
roles:
- global
web:
image: dockercloud/quickstart-python
links:
- redis
target_num_containers: 4
redis:
image: redis
lb/web/redis:
Each key define in docker-cloud.yml creates a service with that name in Docker Cloud.
* Create a Stack:
- from the web interface
- using CLI:
docker-cloud stack create -f docker-cloud.yml
* Update an existing stack:
- specify an existing stack when you create a service
- later want to add a service to an existing stack
- from the Docker Cloud web interface
- using CLI:
docker-cloud stack update -f docker-cloud.yml (uuid or name)
实际操作过程总结
.../test/ykw_BonjourAUSY
docker-machine ls
docker-machine start BonjourAUSY
docker-machine env BonjourAUSY
eval $(docker-machine env BonjourAUSY)
docker login
docker image ls
docker-compose up -d # to run docker-compose.yml
docker exec [OPTIONS] CONTAINERS COMMAND [ARG...]
- Run a command in a running container
- docker exec only runs a new command in a running container and not restarted if the container is restarted
docker run --name ubuntu_bash --rm -it ubuntu bash
docker exec -d ubuntu_bash touch /tmp/execWords
# create a new file (/tmp/execWords) inside the running container (ubuntu_bash), in the background
docker exec -it ubuntu_bash bash
# execute an interactive bash shell on the container
docker-compose ps
to see the running local services
docker container ps
to see the local containers