linux⑨ docker 容器和 rabbitmq 队列_系统运维

概述目录一. docker 容器二. rabbitmq 消息队列一. docker 容器　　1.docker是什么? 1.linux下容器技术有很多，docker是做的最杰出的一款2.docker能够支撑阿里双十一，京东618的业务，说明，性能，安全性不得差3.docker容器很容易被大规模创建4.python为什么火?因为运维领域，golang则是因为doc

一. docker 容器二. rabbitmq 消息队列

一. docker 容器　　1.docker是什么?

1.linux下容器技术有很多，docker是做的最杰出的一款2.docker能够支撑阿里双十一，京东618的业务，说明，性能，安全性不得差3.docker容器很容易被大规模创建4.python为什么火?因为运维领域，golang则是因为docker5.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 容器IDdocket 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.repowget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo3.  此时基于阿里云的yum源下载vimyum install vim -y 4.退出容器空间exit5.提交这个容器记录，生成一个新的镜像文件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.py0~65535 端口范围

　　11.托管docker镜像的网址

#登录dockerhub个人主站，托管docker镜像的网址https://hub.docker.com/yuchao163Zz2222zz 1.下载dockerhub上的镜像docker pull yuchao163/s13-hello-docker-world2.在linux登录docker hub，然后推送镜像到公网docker login 3.修改本地镜像的名字，为docker hub的仓库IDdocker tag 镜像ID   dockerhubID/镜像名

4.推送镜像到docker hubdocker push 镜像ID

　　12. dockefile 的学习

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

指令如下 (不是配置)

#你的项目依赖于什么 *** 作系统，这里就指定什么 *** 作系统 
①FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base imageFROM centos #使用base imageFROM 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 cdworkdir /test #如果没有就自动创建workdir demo #再进入demo文件夹RUN pwd     #打印结果应该是/test/demo④# ADD是可以将本地代码，添加到容器空间内# ADD不仅仅是添加，还可以解压缩文件，注意！！ADD and copY ADD hello /  #把本地文件添加到镜像中，吧本地的hello可执行文件拷贝到镜像的/目录ADD test.tar.gz /  #添加到根目录并解压workdir /rootADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径#copy 就是将宿主机的文件，拷贝到容器空间内，且没有解压效果 copY hello test/  #等同于上述ADD效果ADD与copY   - 优先使用copY命令    -ADD除了copY功能还有解压功能         ⑤   添加远程文件/目录使用curl或wgetENV #环境变量，尽可能使用ENV增加可维护ENV MysqL_VERSION 5.7 #设置一个MysqL常量RUN yum install -y MysqL-server=“${MysqL_VERSION}”

　　②举例比较:

#如果我们启动了一个docker容器docker exec -it 交互式的进入容器空间，进入后可以手动yum解决依赖关系1.手动的yum下载 wget2.手动的 下载 阿里云的yum源3.手动的下载vim 4.手动的进入到 /opt目录dockerfileRUN  yum下载 wgetRUN  下载 阿里云的yum源RUN 下载vim WORDIR  /opt

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

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

　　cat s18-flask.py

from flask import Flaskapp=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

确保文件都准备好了，如下所示[[email protected] s18dockerfile]# lsCentOS-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   registry2.修改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.Json4.重启docker的服务systemctl daemon-reloadsystemctl restart docker5.重新启动一个私有镜像仓库的容器实例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-world7.检查docker私有仓库的API地址，检查Json数据http://192.168.226.128:5000/v2/_catalog8.尝试下载私有仓库的镜像docker pull 192.168.226.128:5000/s18-hello-world

二. rabbitmq 消息队列　　1.安装登录

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

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

安装学习rabbitmq消息队列，配置好阿里云的yum源1.yum -y install erlang  rabbitmq-server2.启动rabbitmq服务端systemctl start rabbitmq-server3.开启rabbitmq的web控制台rabbitmq-plugins enable rabbitmq_management4.重启后生效web界面http://192.168.226.128:15672/5.创建rabbitmq用户sudo rabbitmqctl add_user yangyang 123?6.设置用户的权限，为admin管理员权限sudo rabbitmqctl set_user_Tags yangyang administrator7.允许yangyang这个用户对所有的队列进行读写sudo rabbitmqctl set_permissions -p "/" yangyang ".*" ".*" ".*"8.可以用yangyang登录 rabbitmq的后台界面管理了

　　2.生产 - 消费者模型

　　①生产者 send.py 文件

#!/usr/bin/env pythonimport 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",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 pikacredentials = 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()

总结

以上是内存溢出为你收集整理的linux⑨ docker 容器和 rabbitmq 队列全部内容，希望文章能够帮你解决linux⑨ docker 容器和 rabbitmq 队列所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/yw/1026462.html