linux --- 9. docker 容器 和 rabbitmq 队列

扶醉桌前 提交于 2020-05-02 07:35:58

一. docker 容器

  1.docker是什么?

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能保证服务器的环境一致性

 

 

  2.docker 的三大概念

容器  container            基于镜像,运行出的容器实例  
镜像 image 系统镜像, 电脑城,老板卖的光盘 了,
            只要基于这个镜像光盘,安装的系统,环境完全一致性
仓库 存放镜像的地方


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

 

注:

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

 

  3.安装

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


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


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

yum install docker  -y 


3.启动docker服务端

systemctl start docker

 

4.查看状态

systemctl status docker

 

   4.配置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   

 

  5.增

①
#获取一个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"

 

  6.删


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

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

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



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


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

 

 

  7.改

#进入正在运行的容器空间内
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`

 

  8.查

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

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

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

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

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

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

 

 

  9.导入,导出  镜像

#构建自己自己的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

 

   10.端口映射

① 随机端口
#容器内的端口映射,是在容器空间内,暴露一个端口,供给外部客户端去访问 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 端口范围

 

   11.托管docker镜像的网址

 

#登录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

 

 

 

   12. dockefile  的学习

  ①基本指令(自己创建的文件)

指令如下 (不是配置)

#你的项目依赖于什么操作系统,这里就指定什么操作系统
① 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=“yc_uuu@163.com"
② #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

 

   ③ dockerfile 实战, 构建自己的flaks镜像

  1.准备一个flask代码文件,内容如下

  cat s18-flask.py 

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)

 

   2.编写dockerfile

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代表你要执行的命令

 

  3.构建 build 这个dockerfile

 

确保文件都准备好了,如下所示
[root@wangdachui s18dockerfile]# ls
CentOS-Base.repo  Dockerfile  epel.repo  s18-flask.py

 

   4. 构建 dockerfile 的镜像

docker build .

 

   5.通过自己构建的镜像,运行flask程序

 

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

 

   6.通过浏览器去访问linux宿主机的 5555端口,

即可访问到flask程序

 

 

 

   13.搭建私有docker 仓库

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 消息队列

  1.安装 登录

  注意,保证服务器的内存足够,磁盘足够,以及删除/etc/hosts中没有用的dns解析 

    优点,能够保证消息数据持久化,不丢失

安装学习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 1236.设置用户的权限,为admin管理员权限
sudo rabbitmqctl set_user_tags yangyang administrator

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


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

 

  2.生产 - 消费者模型

  ①生产者 send.py  文件

#!/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()

 

  ② 消费者 receive.py 文件

可以同时存在多个接受者,等待接收队列的消息,默认是轮训方式分配消息

接受者receive.py,可以运行多次,运行多个消费者

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()

 

 

  3.队列的持久化

需要将queue,exchange和Message都持久化。

  ①生产者

import pika
# 无密码
# connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61'))
# 有密码
credentials = pika.PlainCredentials("yangyang","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.119.10',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","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.119.10',credentials=credentials))
channel = connection.channel()
# 确保队列持久化
channel.queue_declare(queue='LOL',durable=True)

'''
必须确保给与服务端消息回复,代表我已经消费了数据,否则数据一直持久化,不会消失
'''
def callback(ch, method, properties, 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()

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!