当你发现自己的才华撑不起野心时,就请安静下来学习吧。

Personal site

↑点击传送

Docker

介绍

各种软件是什么语言写的?

zabbix(监控软件):php

ansible(批量管理主机,执行命令,无angent):python

openstack(云计算,管理虚拟机):python

jekins(ci/di):自动化部署,java

salstack(批量管理主机,执行命令,有angent):python

普罗米修斯(Prometheus,监控):go

docker:go

k8s(kubernetes):go

什么是虚拟化?

-如:vmware,kvm,openstack,docker,k8s(kubernetes)

-云服务器:vmware,kvm虚拟化出来的

-阿里云,腾讯云,openstack,阿里飞天,用来管理虚拟化出来的操纵系统

-docker:进程级别的隔离,装在虚拟机,云服务器上,一个云服务器上开业跑出成百上千个docker容器,成百上千的服务器上,就会有个上万的容器

-k8s:不同机器的上万个容器如何管理

-虚拟化:打破实体结构间的不可切割的障碍

什么是docker?

-go语言实现,开源出来,很多人用

-docker-ce(免费),docker-ee(收费)

-通过go语言对lxc技术的一个封装

-上手快,简单

容器与虚拟机比较

-docker不需要虚拟硬件和操作系统,轻量级,占用体积小,启动快

Docker是一个客户端-服务端(c/s)架构程序(mysql,redis都是cs架构),整套Restful API规范

Docker非常重要的概念:镜像(image)与容器(container)

-有了镜像---》镜像运行起来是容器(真正的执行单位)

镜像从哪里来?

-镜像就是一堆文件

-从远程仓库拉取

Docker架构图

安装Docker

windows安装

windows安装(不建议你装)http://get.daocloud.io/

ubuntu安装

# 0 之前安装过先卸载
	sudo apt-get remove docker docker-engine docker.io containerd runc

# 1 安装必要工具
    sudo apt-get update
    sudo apt-get install \
        apt-transport-https \
        ca-certificates \
        curl \
        gnupg-agent \
        software-properties-common
        
# 2 安装GPG证书
	curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
	#换成阿里云
	curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
	# 写入软件源信息
	#官方
	sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs)stable"
	#换成阿里云
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

# 3 更新并安装docker-ce
	sudo apt-get -y install docker-ce
    
# 4 开启docker服务
	systemctl status docker

centos安装

# 6.8安装docker,自行搜索,升级内核版本

# docker是在linux3.1以上内核中写出来的,在乌班图下开发的,docker的新特性,乌班图先看到

# 官方建议docker运行在centos7 以上的系统

#安装
0 卸载(之前有安装过先卸载)
	yum remove docker docker-common  docker-selinux docker-engine
	rm -rf /var/lib/docker

1 更新yum
	yum update
    
2 安装需要的软件包, yum-util 
	yum install -y yum-utils device-mapper-persistent-data lvm2
    
3 执行(向你的yum源,增加一条记录)
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
4 安装 
	yum install docker-ce

5 验证安装(查看版本)
	docker -v  
    # 自从分了docker-ce和docker-ee以后,以年份命名版本
    Docker version 19.03.12, build 48a66213fe	#(19年03月12日发布)

6 启动docker服务
	systemctl start docker

7 停止docker服务,重启docker服务
    systemctl stop docker
    systemctl restart docker

8 开机启动	
	systemctl enable docker

9 查看概要信息
	docker info(你可能写了一个管理docker的运维平台)

远程仓库

# 注册,登录 https://hub.docker.com/

# 你可以上传镜像(类似于github),你把你制作的镜像传上去,别人可以下载使用

# 配置加速(之前去https://hub.docker.com/),阿里云,清华,做了一个备份,配置好以后,再拉镜像会去国内地址拉取
    第一步:vi /etc/docker/daemon.json  
    第二步:
    {
    "registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
    }

镜像操作

1 第一个hell0-world(没有任何意义)
	docker run hello-world
    1 客户端连到服务端,服务端下载了hello-world镜像
    2 通过镜像跑起容器来
    3 容器输出了一些东西,通过服务端发送给客户端,客户端展示在窗口上了
    
2 查找镜像
	方式一:https://hub.docker.com/ 点点点搜索(你用这种)
    方式二:docker search	
    
3 拉取镜像
	docker pull hello-world 最新版本latest
    docker pull hello-world:nanoserver

4 查看机器上有哪些镜像
	docker images
    REPOSITORY  TAG   IMAGE ID  CREATED    SIZE
    镜像名字	  版本	id号		创建时间	大小
    
5 删除镜像
	docker rmi 镜像名字/id号 #如果还有基于镜像的容器,是不允许删除的,先输出容器,再删除images,或者加f强制删除docker rmi -f 镜像名字/id号
    
6 练习:拉取python3.6镜像,redis镜像,mysql5.7镜像
	docker pull python:3.6
    docker pull redis
    docker pull mysql:5.7
    docker pull centos:centos7
        
7 镜像是什么?
	镜像是一堆文件,这堆文件通过docker跑起来,就是容器,你现在就把他当成,一个操作系统跑了这个软件(centos+redis)
    假设centos的镜像跑起来,容器你就当成在你的宿主机上跑了一个centos7的操作系统(虚拟机)
    好比 类和对象

容器操作

1 删除容器
	docker rm 容器名字/容器id
    
2 启动并运行容器
	#通过centos:centos7镜像,创建容器名字叫mycentos,并且把它运行起来
    docker run -di --name=mycentos centos:centos7	#打印出容器的id
        
3 查看机器上正在运行的容器
	docker ps
    
4 查看宿主机上所有的容器(包括停止的)
	docker ps -a
    
5 停止容器
	docker stop 容器名字/id号
    
6 启动容器
	docker start 容器名字/id号
    
7 容器的创建和启动(******)
	-创建:docker create --name=xxx redis docker create --name=test-container centos:centos7 ps -A
    -启动:docker start test-container
    -容器一直运行的原因:
    	-它有一条前台进程,一致运行
        -以后如果自己制作镜像,运行起容器,必须有个可以夯住的命令
        -如果该命令结束,该容器也就结束了
    -创建并启动(run)
        -i:表示运行容器
        -t:表示容器启动后会进入其命令行。加入这两个参数后,容器创建就能登录进去。即分配一个伪终端。
        -d:在run后面加上-d参数,则会创建一个守护式容器在后台运行(这样创建容器后不会自动登录容器,如果只加-i -t两个参数,创建后就会自动进去容器)。
        --name :为创建的容器命名。如果不写,会自动分配一个名字(英文人名)
        -v:表示目录映射关系(前者是宿主机目录,后者是容器目录,映射到宿主机上的目录),可以使用多个-v做多个目录或文件映射。注意:最好做目录映射,在宿主机上做修改,然后共享到容器上。
        -p:表示端口映射,前者是宿主机端口,后者是容器内的映射端口。可以使用多个-p做多个端口映射
        docker run -it --name=myredis redis
	#注意,docker run 镜像 如果本地没有,会先pull,再run
    
8 进入容器的几种方式(并不是真进入)
	第一种:docker exec -it 容器id /bin/bash
    	docker exec 容器id ls
        exec真正的作用是在容器内执行命令
    第二种:ssh连接(容器内部装ssh服务端)
    
9 退出
	exit
    
10 文件拷贝
	-从宿主机拷贝到容器内部
    	docker cp aaa.txt 容器id:/home
    -从容器内部拷贝到宿主机
    	docker cp 容器id:/home/aaa.txt /home
            
11 目录挂载
	docker run -di -name=mycentos -v /home/lqz:/home centos:centos7
    # 一旦挂载,以后宿主机目录内修改,同样影响容器内部
    
12 端口映射
	docker run -di -p 6377:6379 redis:latest
    #了解: /usr/local/bin/docker-entrypoint.sh
    
13 查看容器详细信息
	docker inspect f81
    docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称(容器ID)

容器部署

# 在容器内部署mysql
	# -e表示环境变量
    docker run -di --name=mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
            
# 官方提供的
	docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
        
# 在容器内部署redis
	docker run -di -p 6377:6379 redis:latest
        
# 在容器内部署nginx
	docker run -di --name=mynginx -p 8080:80 nginx

部署应用映射外部目录

#部署redis,把配置文件和数据目录映射出来
#操作步骤
	-1 mkdir -p /reids /redis/conf /redis/data
    
    -2 vim /redis/conf/redis.conf
        # 配置文件
        bind 0.0.0.0
        daemonize NO
        protected-mode no
        requirepass 123456
        
    -3 创建并运行容器
    docker run -p 6378:6379 --name=redis_6379 -v /redis/conf/redis.conf:/etc/redis/redis.conf -v /redis/data:/data -di redis redis-server /etc/redis/redis.conf
                
    -4 本地window机器上远程连接到了docker里的redis
    
    -5 cmd窗口下
    	redis-cli -h 101.133.225.166 -p 6378
        
    -6 认证
    	auth 123456
        
    -7 写入数据
    	set name lqz
        
    -8 保存数据
    	save或者是bgsave(后台保存)
        
    -9 在宿主机的/redis/data路径下就能看到一个文件
    
    -10 不管多少次重启redis容器,数据都还在
    
    -11 原来的redis容器没了,按照第三步再启动一遍,数据都还在

迁移与备份

其他操作

#删除所有容器 
	docker rm `docker ps -a -q`
    
#删除所有镜像
	docker rmi `docker images -q`
    
#查看容器运行日志
	docker logs 容器id
    
#操作步骤
	1 启动一个python容器
    	docker run -di --name=python3 python:3.6
            
    2 进入容器装软件
    	docker exec -it 71c /bin/bash
        mkdir /project
        pip install django==2.0.7 -i https://pypi.douban.com/simple/
        exit
        
    3 把项目拷贝进容器内部
    	docker cp /home python3:/project
            
    4 把容器做成镜像
    	docker commit python3 mydjango
        
    5 基于自己做的镜像运行容器
    	docker run -id --name=mydjango -p 8088:8088  mydjango python3 /project/test/manage.py runserver 0.0.0.0:8088  #使用python manage.py runserver 0.0.0.0:8088启动   

镜像打包成压缩包

docker save -o test.tar test

镜像压缩包恢复为容器

docker load -i test.tar

dockerfile(很重要)

1 dockerfile是什么
	一个文件,里面一堆指令,通过这个文件可以生成镜像
    
2 dockerfile指令
	命令	                  作用 
    FROM image_name:tag	定义了使用哪个基础镜像启动构建流程    
        
    MAINTAINER user_name	声明镜像的创建者
    
    ENV key value	设置环境变量 (可以写多条)
    
    RUN command	是Dockerfile的核心部分(可以写多条)
    
    ADD source_dir/file dest_dir/file	将宿主机的文件复制到容器内,如果是一个压缩文件,将会在复制后自动解压
    
    COPY source_dir/file dest_dir/file	和ADD相似,但是如果有压缩文件并不能解压
    
    WORKDIR path_dir	设置工作目录
    
3 写一个dockerfile(文件名字必须交dockerfile),django项目路径下创建dockerfile
    vim dockerfile
        FROM python:3.6
        MAINTAINER joab
        EXPOSE 8080
        ADD ./requirement.txt /home/
        RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/ 
        RUN pip install uwsgi -i https://pypi.douban.com/simple/
        VOLUME ["/home"]
        WORKDIR /home/django_test
        CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"] 
        
4 通过dockerfile构建出镜像
	docker build -t='django_2.0.7' .
    
5 查看镜像
	docker images 
    
6 启动容器
	docker run -di --name=mydjango2 -v /home/django_test/:/home/django_test/ -p 8080:8080 django_2.0.7
            
7 就可以访问了
	http://linqiaobao.xyz:8080/nb/
        
8 配置nginx转发,负载均衡
	# 创建文件件
	mkdir -p /opt/nginx/conf /opt/nginx/html /opt/nginx/logs
    
    # 新建配置文件
    vim /opt/nginx/conf/nginx.conf
    
    # 写入
    worker_processes  1;
    events {
        worker_connections  1024;
    }
    http {
        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  65;
        upstream node	{
            server	39.97.209.187:8080;
            server	39.97.209.187:8081;
            server	39.97.209.187:8082;
        }
        server {
            listen       80;
            server_name  localhost;
            location / {
              #proxy_pass http://101.133.225.166:8080;
              #负载均衡配置
              proxy_pass http://node;
            }  
        }
    }

    # 多启动几个docker容器,如果其中的一两个挂掉也不影响使用,启动命令后加 /bin/bash/  夯住
    docker run -di --name=mydjango3 -v /home/django_test/:/home/django_test/ -p 8081:8080 django_2.0.7
    docker run -di --name=mydjango4 -v /home/django_test/:/home/django_test/ -p 8082:8080 django_2.0.7    
            
    # docker中运行nginx,监听8888端口,nginx随机转发到8080,8081,8082端口,达到负载均衡
    docker run --name nginx -id -p 8888:80 -v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v 	/opt/nginx/html:/etc/nginx/html -v /opt/nginx/logs:/var/log/nginx nginx

    # 假设8081的容器挂了,8080的容器挂了,正常提供服务
    
    # 后续再把挂掉的docker容器启动起来即可
    docker start 容器id/容器名称

私有仓库

准备

1 把自己的镜像传到docker hub上
	-docker login  输入用户名密码
    -给你要上传的image打个标签docker tag 5452fa6715c0 liuqingzheng/django1.11.9:v1
    -docker images
    -docker push liuqingzheng/django1.11.9:v1

步骤

1 拉取私有仓库镜像
	docker pull registry
2 启动容器
	docker run -di --name=registry -p 5000:5000 registry
3 打开浏览器 输入地址http://101.133.225.166:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
4 配置
	修改daemon.json
	vi /etc/docker/daemon.json
    添加以下内容,保存退出。
    {"insecure-registries":["101.133.225.166:5000"]} 
    此步用于让 docker信任私有仓库地址
5 重启docker 服务
	systemctl restart docker
6 重启容器
	docker start registry
7 打标签
	docker tag 5452fa6715c0 101.133.225.166:5000/django1.11.11
8 上传到私有仓库
docker push 101.133.225.166:5000/django1.11.11
    
9 从私有仓库拉取镜像
docker pull 101.133.225.166:5000/django1.11.11

docker-compose

1 Docker Compose是一个能一次性定义和管理多个Docker容器的工具(单机情况下的),多级管理容器的有k8s(谷歌出的)

2 通过yml文件定义多个容器

3 默认名字docker-compose.yml

4 三个概念,Service  Networks ,Volumes
	一个service代表一个container,这个container可以从docker hub的image来创建,或者从本地dockerfile build的image来创建
    
5 version:有1,2,3版本,目前都用"3"

6 安装命令
    curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

    chmod +x /usr/local/bin/docker-compose

7 验证安装成功
	docker-compose -v

docker-compose命令

# 启动管理容器
docker-compose up  # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d  # 后台执行,一般我们看日志输出,不用这个

docker-compose stop  # 停止,不会删除容器和镜像
docker-compose down # 停止,并删除关联的容器
docker-compose start  # 启动yml文件管理的容器
docker-compose ps    # 正在运行的容器
docker-compose images # docker-compose管理的容器

docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内

部署多应用

# 部署flask redis
    1 创建Dockerfile
    vim Dockerfile
        FROM python:3.6
        COPY . /app
        WORKDIR /app
        RUN pip install flask redis
        EXPOSE 5000
        CMD [ "python", "app.py" ]

	2 创建docker-compose文件
    vim docker-compose.yml
        version: "3"
        services:
          redis:
            image: redis
          web:
            build:
              context: .
              dockerfile: Dockerfile
            ports:
              - 8086:5000
            environment:
              REDIS_HOST: redis
                
    3 创建app.py
    vim app.py
        from flask import Flask
        from redis import Redis
        import os
        import socket
        app = Flask(__name__)
        redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
        @app.route('/')
        def hello():
            redis.incr('hits')
            return '你好! 查看 %s 次, hostname 是 %s.\n' % (redis.get('hits'),socket.gethostname())
        if __name__ == "__main__":
            app.run(host="0.0.0.0", port=5000, debug=True)
            
    4 启动--运行
    docker-compose up
    
    #5 水平扩展wed成3个
    #vim app.py
    from flask import Flask
    from redis import Redis
    import os
    import socket
    app = Flask(__name__)
    redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
    @app.route('/')
    def hello():
        redis.incr('hits')
        return '你好! 查看 %s 次, hostname 是 %s.\n' % (redis.get('hits'),socket.gethostname())
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=80, debug=True)
        
    #vim docker-compose.yml
    
    version: "3"
    services:

      redis:
        image: redis

      web:
        build:
          context: .
          dockerfile: Dockerfile
        environment:
          REDIS_HOST: redis

      lb:
        image: dockercloud/haproxy
        links:
          - web
        ports:
          - 8080:80
        volumes:
          - /var/run/docker.sock:/var/run/docker.sock 
                
	# 把web扩展为3个从浏览器查看
    docker-compose up --scale web=3 -d
    
    # 减掉为1个
    docker-compose up --scale web=1 -d                
    
    

docker-compose.yml如何写

version: '3'
services:
  wordpress:
    image: wordpress
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_PASSWORD: root
    volumes:
      - mysql-data:/var/lib/mysql

使用Docker Compose部署一个wordpress

# 第一步:docker-compose.yml
version: '3'
services:
  wordpress:
    image: wordpress
    ports:
      - 8080:80
    depends_on:
      - mysql
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_PASSWORD: root
    networks:
      - my-bridge

  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: wordpress
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - my-bridge

volumes:
  mysql-data:

networks:
  my-bridge:
    driver: bridge
      
      
# 第二步:docker-compose up

环境变量

容器启动的时候-e设置进去,项目内os.environ.get('密码'),隐藏密码

多个容器间直接通信方式

1 端口映射到宿主机,直接访问宿主机

2 通过ip地址访问

3 run的时候指定 --link 容器 
    docker run -di --name=centos1 centos:centos7
    docker run -di --name=centos2 --link centos1 centos:centos7
    
进入到centos2中 ping centos1 可以ping同


# 跨主机的容器通信
	-端口映射
posted @ 2020-09-16 18:30  Joab-0429  阅读(141)  评论(0编辑  收藏  举报