1.linux下容器技术有很多，docker是做的最杰出的一款

2.docker能够支撑阿里双十一，京东618的业务，说明，性能，安全性不得差

3.docker容器很容易被大规模创建

4.python为什么火?因为运维领域，golang则是因为docker

5.docker能够解决什么问题？解决环境配置问题

6.每一个docker容器，单独运行一个应用程序

7.docker如同在os的进程上，披着一个马甲，其实还是运行在一个单独linux系统上

8.让开发人员最头疼的就是，环境配置问题，运行一个crm，可能要解决很多的依赖关系，才能运行 

保证操作系统一致性，你本地是windows，服务器可能是centos/ubuntu
你本地开发的是python3，也得保证服务器是python3
还得解决pip的依赖包，linux的PATH变量等等

9.有没有一种办法，能把本地的开发代码，和环境，全部切换到服务器上呢？

解决办法1：vmware 虚拟机模板克隆功能

解决办法2：
docker容器技术
基于系统镜像，安装好的操作系统。
将你的应用程序，和代码，全部打包在一个系统镜像内，（docker image  容器镜像），
镜像就是一个操作系统的压缩文件

10.docker能保证服务器的环境一致性

容器  container            基于镜像，运行出的容器实例  

镜像  image         系统镜像,电脑城，老板卖的光盘 了，
　　　　　　　　　　　　只要基于这个镜像光盘，安装的系统，环境完全一致性 

仓库  存放镜像的地方 

基于docker镜像，运行出实例?
容器 就像是 类的实例化
镜像 就像是 class

?

注:

#托管代码的平台，叫做github
#托管docker镜像的平台，docker hub

1.yum安装，必须得指定yum源，yum源大致分为，centos官方的源，
阿里云这样的第三方源，docker官方源（生产环境配置它，最正确）


获取docker社区版
社区ce缩写
企业版是EE缩写 


2.选择阿里云的安装方式，配置好阿里云的yum源

yum install docker  -y 

3.启动docker服务端

systemctl start docker

?

4.查看状态

systemctl status docker

curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | 
sh -s http://95822026.m.daocloud.io

vim /etc/docker/daemon.json
#修改如下
{"registry-mirrors": ["http://95822026.m.daocloud.io"]}  #去掉结尾的逗号

sudo systemctl restart docker　　?

①
#获取一个hello-world镜像,默认去docker hub 搜索docker镜像
docker search   hello-wolrd    #搜索镜像
docker pull hello-world   #下载镜像，就如同我骑车去电脑城买光盘一样 ，目的都是为了回去一个镜像文件


#基于镜像，运行出容器实例
docker run hello-world  #运行hello-world镜像文件  #语法是 ，docker  run  镜像名 


②
#下载ubuntu的镜像文件    ，下载一个微型的ubuntu系统
docker pull ubuntu

#运行一个ubuntu系统！！！！基于微型的ubuntu系统，运行了一个容器实例，里面是ubuntu微型操作系统
docker run ubuntu 


#交互式的运行一个ubuntu系统，可以进行命令交互,，并且进入容器空间内，另一个操作系统
docker run -it ubuntu /bin/bash
    #参数解释
    -i 交互式的运行
    -t  开启一个终端 termenl
    /bin/bash 就是linux的shell解释器  ，


③    
#运行一个交互式的centos容器记录

docker run -it centos 
    
    
什么是linux的shell解释器？ 

python解释器是用来解释且执行python代码的
shell解释器是用来解释且执行shell代码的，我们输入的ls  cd  都是通过shell进行翻译，linux才认识的
shell和python都是一个语言的解释器


④
#运行一个后台有进程的容器，活着的容器
docker run -d centos /bin/sh -c "while true;do echo 买了佛冷; sleep 1;done"
    #参数解释
    docker run  运行镜像
    -d   daemonize  后台运行
    centos  镜像名
    /bin/sh   指定shell的sh解释器
    -c  指定一段shell代码
    "while true;do echo 买了佛冷; sleep 1;done"            #死循环的每秒钟打印一个买了佛冷
    
#运行一个自定义名字的容器记录 
 docker run --name s18foleng -d centos /bin/sh -c "while true;do echo 买了佛冷; sleep 1;done" 

①
#删除容器记录
docker rm 容器id

#一次性删除所有容器记录

docker rm `docker ps -aq`
`` 反引号是取得命令的结果，保存下来

②
#删除镜像
docker rmi 镜像id(可写前三个)

docker rmi -f `docker images -aq`?
#危险命令 ，这个命令，只能删除没有容器记录依赖的镜像文件?
-f 强制删除

?

#进入正在运行的容器空间内
docker exec -it 容器id  /bin/bash 

#修改docker镜像的名字

docker tag 镜像id   新的镜像名
docker  tag  9ed836d5dd03  yuchao163/s18-aliyun-centos-vim 


#启停docker容器
docker start 容器id
docket stop 容器id

#批量停止docker容器
docker stop `docker ps -aq`

#查询当前机器拥有的镜像文件
docker image ls  #列出镜像文件
docker images  #同上，版本升级，命令也就升级了 

#运行过镜像后，会产生一个容器记录，容器进程的查看

docker  ps          #查看正在运行的容器记录 ，容器内必须有后台运行的进程，否则容器挂掉 

docker ps  -a  #显示所有运行过的容器进程记录

#查询容器内的日志信息
docker logs  容器id  #一次性打印日志
docker logs -f  容器id  #不间断打印容器日志 

cat /etc/os-release  查看本机的具体系统参数

#构建自己自己的docker镜像，提交本地的docker容器 
1.运行一个centos基础镜像，默认没有vim，在容器空间内安装vim(也可以替换成python)，且配置阿里云的yum源  

docker run -it centos /bin/bash 

2.安装wget，下载阿里云的yum源
yum install wget -y  

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo


3.  此时基于阿里云的yum源下载vim
yum install vim -y 

4.退出容器空间
exit

5.提交这个容器记录，生成一个新的镜像文件
docker commit  容器id   镜像名

docker commit  b6a15b909caa  yuchao163/s18-vim-aliyun-centos 



6.导出这个镜像，成为一个压缩文件，我就可以给大家发送下去 

#导出docker镜像
docker save   9ed836d5dd03  > /opt/mydocker.tar.gz


#导入docker镜像
docker load  <  /opt/mydocker.tar.gz

① 随机端口
#容器内的端口映射，是在容器空间内，暴露一个端口，供给外部客户端去访问
docker run -d -P     training/webapp     python app.py
    #参数解释
    -d  后台运行容器
    -P   大写的P 随机端口映射   宿主机端口：容器内端口   随机的映射宿主机的端口：容器内的端口
    -p   小写的p  指定端口映射   8080:8000
    training/webapp        这个是镜像的名字
    python app.py  容器要执行的命令 
    
#docker run 如果运行不存在的镜像，默认会去先docker pull
 
② 指定端口
#指定端口映射，暴露宿主机的7000，指定映射到容器的5000，这个5000是在容器代码内控制的
docker run -d -p   7000:5000     training/webapp     python app.py

0~65535 端口范围

#登录dockerhub个人主站，托管docker镜像的网址

https://hub.docker.com/

yuchao163
Zz2222zz 


1.下载dockerhub上的镜像
docker pull yuchao163/s13-hello-docker-world


2.在linux登录docker hub，然后推送镜像到公网

docker login 

3.修改本地镜像的名字，为docker hub的仓库id
docker tag 镜像id   dockerhubID/镜像名

?

4.推送镜像到docker hub

docker push 镜像id

?

指令如下 (不是配置)


#你的项目依赖于什么操作系统，这里就指定什么操作系统 
①
FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
FROM centos #使用base image
FROM ubuntu:14.04 #带有tag的base image

#label标签 ，告诉别人，这个dockerfile是谁写的
LABEL version=“1.0” #容器元信息，帮助信息，Metadata，类似于代码注释
LABEL     maintainer=“[email?protected]"


②
#run指令是一个万能指令 

#对于复杂的RUN命令，避免无用的分层，多条命令用反斜线换行，合成一条命令！
RUN yum update && yum install -y vim     Python-dev #反斜线换行
RUN /bin/bash -c "source $HOME/.bashrc;echo $HOME”


③

#
WORKDIR /root #相当于linux的cd命令，改变目录，尽量使用绝对路径！！！不要用RUN cd
WORKDIR /test #如果没有就自动创建
WORKDIR demo #再进入demo文件夹
RUN pwd     #打印结果应该是/test/demo

④
# ADD是可以将本地代码，添加到容器空间内
# ADD不仅仅是添加，还可以解压缩文件，注意！！

ADD and COPY 
ADD hello /  #把本地文件添加到镜像中，吧本地的hello可执行文件拷贝到镜像的/目录
ADD test.tar.gz /  #添加到根目录并解压




WORKDIR /root
ADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径


#copy 就是将宿主机的文件，拷贝到容器空间内，且没有解压效果 


COPY hello test/  #等同于上述ADD效果

ADD与COPY
   - 优先使用COPY命令
    -ADD除了COPY功能还有解压功能
    
    
 ⑤   
添加远程文件/目录使用curl或wget

ENV #环境变量，尽可能使用ENV增加可维护

ENV MYSQL_VERSION 5.7 #设置一个mysql常量

RUN yum install -y mysql-server=“${MYSQL_VERSION}”

#如果我们启动了一个docker容器
docker exec -it 交互式的进入容器空间，进入后可以手动yum解决依赖关系

1.手动的yum下载 wget
2.手动的 下载 阿里云的yum源
3.手动的下载vim 
4.手动的进入到 /opt目录




dockerfile

RUN  yum下载 wget
RUN  下载 阿里云的yum源
RUN 下载vim 
WORDIR  /opt  

from flask import Flask
app=Flask(__name__)
@app.route(‘/‘)
def hello():
    return "hello,i am docker"
if __name__=="__main__":
    app.run(host=‘0.0.0.0‘,port=8080)

FROM centos        #指定centos基础镜像 
COPY CentOS-Base.repo /etc/yum.repos.d/        #拷贝宿主机的文件，到容器空间下
COPY epel.repo /etc/yum.repos.d/             #拷贝宿主机的文件，到容器空间下
RUN yum clean all                             #执行清空yum缓存的命令
RUN yum install python-setuptools -y        #想安装python依赖工具
RUN easy_install flask                        #是想让docker自动的帮咱们安装python2的flask模块
COPY s18-flask.py /opt/                        #把本地的代码文件，拷贝到容器的/opt目录下 
WORKDIR /opt                                #进入到/opt目录下
EXPOSE 8080                                    #暴露容器的8080端口，供给外部宿主机去访问
CMD ["python","s18-flask.py"]                #cmd代表你要执行的命令

确保文件都准备好了，如下所示
[[email?protected] s18dockerfile]# ls
CentOS-Base.repo  Dockerfile  epel.repo  s18-flask.py

docker build .

docker run -d --name flask  -p 5555:8080  s18-flask

1.下载docker私有镜像
docker pull   registry

2.修改docker的配置文件 
#修改如下配置文件
vim /etc/docker/daemon.json


修改内容如下
{"registry-mirrors": ["http://95822026.m.daocloud.io"],"insecure-registries":["192.168.226.128:5000"]
}

3.修改docker的service配置文件，让它加载/etc/docker/daemon.json
修改如下文件
vim /lib/systemd/system/docker.service

添加如下配置到 [service]代码块中
EnvironmentFile=-/etc/docker/daemon.json

4.重启docker的服务
systemctl daemon-reload
systemctl restart docker

5.重新启动一个私有镜像仓库的容器实例

docker run --privileged=true -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry     registry

--privileged=true  docker容器的安全机制：设置特权级运行的容器
- v 宿主的文件夹映射到容器的文件夹

6.推送本地镜像，到私有仓库中
docker push 192.168.226.128:5000/s18-hello-world

7.检查docker私有仓库的api地址，检查json数据
http://192.168.226.128:5000/v2/_catalog

8.尝试下载私有仓库的镜像
docker pull 192.168.226.128:5000/s18-hello-world

安装学习rabbitmq消息队列，配置好阿里云的yum源

1.yum -y install erlang  rabbitmq-server

2.启动rabbitmq服务端
systemctl start rabbitmq-server

3.开启rabbitmq的web控制台
rabbitmq-plugins enable rabbitmq_management

4.重启后生效web界面
http://192.168.226.128:15672/

5.创建rabbitmq用户
sudo rabbitmqctl add_user yangyang 123
?
6.设置用户的权限，为admin管理员权限
sudo rabbitmqctl set_user_tags yangyang administrator

7.允许yangyang这个用户对所有的队列进行读写
sudo rabbitmqctl set_permissions -p "/" yangyang ".*" ".*" ".*"


8.可以用yangyang登录 rabbitmq的后台界面管理了

#!/usr/bin/env python
import pika
# 创建凭证，使用rabbitmq用户密码登录
# 去邮局取邮件，必须得验证身份
credentials = pika.PlainCredentials("yangyang","123")
# 新建连接，这里localhost可以更换为服务器ip
# 找到这个邮局，等于连接上服务器
connection = pika.BlockingConnection(pika.ConnectionParameters(‘192.168.119.10‘,credentials=credentials))
# 创建频道
# 建造一个大邮箱，隶属于这家邮局的邮箱，就是个连接
channel = connection.channel()
# 声明一个队列，用于接收消息，队列名字叫“水许传”
channel.queue_declare(queue=‘水许传‘)
# 注意在rabbitmq中，消息想要发送给队列，必须经过交换(exchange)，初学可以使用空字符串交换(exchange=‘‘)，它允许我们精确的指定发送给哪个队列(routing_key=‘‘),参数body值发送的数据
channel.basic_publish(exchange=‘‘,routing_key=‘水许传‘,#这里写队列的名字
                      body=‘武松又去打老虎啦2‘)   # 消息
print("已经发送了消息")
# 程序退出前，确保刷新网络缓冲以及消息发送给rabbitmq，需要关闭本次连接
connection.close()

import pika
# 建立与rabbitmq的连接
credentials = pika.PlainCredentials("s14","123")
connection = pika.BlockingConnection(pika.ConnectionParameters(‘192.168.119.10‘,credentials=credentials))
channel = connection.channel()
channel.queue_declare(queue="水许传")

def callbak(ch,method,properties,body):
    print("消费者接收到了任务：%r"%body.decode("utf8"))
# 有消息来临，立即执行callbak，没有消息则夯住，等待消息
# 老百姓开始去邮箱取邮件啦，队列名字是水许传
channel.basic_consume(callbak,queue="水许传",no_ack=True)
# 开始消费，接收消息   no_ack = true 不需要确认回复
channel.start_consuming()

import pika
# 无密码
# connection = pika.BlockingConnection(pika.ConnectionParameters(‘123.206.16.61‘))
# 有密码
credentials = pika.PlainCredentials("yangyang",credentials=credentials))
channel = connection.channel()
# 声明一个队列(创建一个队列)
# 默认此队列不支持持久化，如果服务挂掉，数据丢失
# durable=True 开启持久化，必须新开启一个队列，原本的队列已经不支持持久化了
‘‘‘
实现rabbitmq持久化条件
 delivery_mode=2
使用durable=True声明queue是持久化
 
‘‘‘
channel.queue_declare(queue=‘LOL‘,durable=True)
channel.basic_publish(exchange=‘‘,routing_key=‘LOL‘,# 消息队列名称
                      body=‘德玛西亚万岁‘,# 支持数据持久化
                      properties=pika.BasicProperties(
                          delivery_mode=2,#代表消息是持久的  2
                      )
                      )
connection.close()

import pika
credentials = pika.PlainCredentials("yangyang",credentials=credentials))
channel = connection.channel()
# 确保队列持久化
channel.queue_declare(queue=‘LOL‘,durable=True)

‘‘‘
必须确保给与服务端消息回复，代表我已经消费了数据，否则数据一直持久化，不会消失
‘‘‘
def callback(ch,body):
    print("消费者接受到了任务: %r" % body.decode("utf-8"))
    # 模拟代码报错
    # int(‘asdfasdf‘)    # 此处报错，没有给予回复，保证客户端挂掉，数据不丢失
   
    # 告诉服务端，我已经取走了数据，否则数据一直存在
    ch.basic_ack(delivery_tag=method.delivery_tag)
# 关闭no_ack，代表给与回复确认
channel.basic_consume(callback,queue=‘LOL‘,no_ack=False)
channel.start_consuming()