docker，mq,salt

docker学习

由于环境部署配置的麻烦问题,出现了以下访问

电脑城老板卖的dvd系统光盘-----docker的镜像文件

基于光盘可以安装出N个一样的操作系统

程序员将代码以及程序依赖,打包成一个docker镜像文件
以后只需要把这个镜像文件,发给测试,运维,只需要安装docker

安装这个镜像文件,就可以运行出开发的环境了

1.虚拟机vmware模板功能
2.利用docker的镜像文件,达到一样的效果

docker的三大生命周期概念

1.镜像文件,可以理解为操作系统的 centos.iso文件
2.容器实例 ,基于docker镜像运行出的容器实例, 可以理解为微型操作系统
3.仓库, 存储镜像文件的地方

docker安装方式
1.yum安装,配置yum仓库
-阿里云仓库,清华源仓库,163仓库, 问题是,docker的版本可能很低,有很多漏洞
-选择软件官方提供的yum仓库,版本都是最新的,但是可能下载较慢
-由于网速问题,学习阶段还是使用阿里云的docker

2.rpm 不推荐
3.源码编译安装,很麻烦,如果没有特定需求,还是选择yum

1.配置阿里云仓库即可安装
yum install docker -y

2.同构yum安装的软件,都可以使用systemctl系统服务管理命令,去启停
systemctl status/start/stop docker #看状态/启动/停止

3.镜像,仓库,容器的增删改查管理命令

#docker镜像下载加速器

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

增

1.获取镜像文件 ,centos或者ubuntu 系统镜像

docker pull 镜像文件名 #下载docker镜像
docker run hello-world #运行镜像文件,生成docker容器实例,docker run命令,会自动下载不存在的镜像
#容器是随时创建,随时删除的,轻量级,每次docker run 都会生成新的容器记录
#docker容器进程,如果没有在后台运行的话,就会立即挂掉, (容器中必须有正在工作的进程)

#运行一个活着的容器进程
docker run -d centos /bin/sh -c "while true;do echo '你个糟老头子,不听课,坏得很'; sleep 1;done"
#运行镜像
-d 后台运行的意思
centos 指的是镜像文件名
/bin/sh 要在这个容器内运行的命令,指定的解释器 shell解释器
-c 指定一段shell代码

#进入容器空间内的命令
docker exec -it 容器id /bin/bash #进入容器空间内
-i 交互式命令操作
-t 开启一个新的终端

#运行一个ubuntu容器
docker run -it ubuntu

删
docker rmi 镜像名字/镜像id #删除镜像文件
docker rm 容器id/容器进程名字 #删除容器记录
docker rmi -f #强制删除镜像文件
docker rm `docker ps -aq` #批量删除容器记录,只能删除挂掉的容器记录

改

#docker容器进程的启停命令

docker start 容器id
docker stop 容器id

查
docker search 镜像文件名字 #搜索镜像文件
docker images #列出当前所有的镜像文件
docker ps #列出当前记录正在运行的容器进程
docker ps -a #列出所有的容器进程,以及挂掉的

docker logs 容器id #查看容器内的日志信息
docker logs -f 容器id #检测容器内的日志

容器镜像

容器进程,基于容器镜像文件运行出的

class s21():
def __init__(self):
self.salary=10000
'''
python编译
yum环境依赖解决
mysql安装
...
'''

小黑=s21()

小绿=s21()

小王=s21()

docker镜像就是python的类,基于这个类可以无限的实例化

docker的容器就是类的实例化对象

#提交自定制的镜像文件

#整个过程如下
运行出容器实例二次修改容器实例提交容器实例为新的镜像导出镜像发给别人导入

1.docker run -it centos /bin/bash #进入一个纯净的centos容器空间内,此时是最小化安装的系统,没有vim 没有py3

2.在容器空间内 yum install vim ,然后退出容器

3.此时这个容器记录就是携带者 vim的容器记录了(可以理解为携带者程序依赖,或者python3等等)

4.提交这个容器为新的镜像文件

docker commit 容器进程id 镜像文件的名字
docker commit 419 s21docker-centos-vim

5.导出docker镜像,成为一个压缩文件,可以发送给你的测试,运维同事了

docker save 镜像文件名 > /opt/s21-centos-vim.tar.gz

6.此时可以发送文件,给别人导入了
docker load < 同事给你发的镜像文件

#容器内运行一个web程序 ,进行端口映射

1.下载一个flask的docker镜像
docker pull training/webapp

2.运行docker镜像

docker run -d -P
-d 后台运行
-P 随机端口映射随机的宿主机的端口:容器内的端口(自动指定的,由代码指定)
-p 指定端口映射宿主机的7777:8500

docker run -d -P training/webapp python app.py #创建一个容器空间,然后在里面执行 python app.py 命令
docker run -d -p 6000:5000 training/webapp python app.py #创建一个容器空间,然后在里面执行 python app.py 命令

3.访问这个容器应用
服务器ip:宿主机的映射端口

123.206.16.61:32768

4.进入容器空间内,查看代码

dockerfile学习,docker的脚本文件,用于构建镜像文件的

FROM scratch #制作base image 基础镜像，尽量使用官方的image作为base image
FROM centos #使用base image
FROM ubuntu:14.04 #带有tag的base image
#FROM指令用于指定容器用什么发行版

#定义标签变量的
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”

RUN yum install redis #自动安装redis

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

WORKDIR /opt

WORKDIR /tmp
WORKDIR ../

# ADD命令用来将宿主机的文件添加到容器空间内
#ADD存在压缩文件解压的功能,因此,仅仅添加文件到容器内,用COPY而不是ADD

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

#
WORKDIR /root
ADD hello test/ #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
COPY hello test/ #等同于上述ADD效果

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

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

ENV MYSQL_VERSION 5.6 #设置一个mysql常量

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

dockerfile构建一个flask web app

1.编写flask代码文件
s21flask.py
#coding:utf8
from flask import Flask
app=Flask(__name__)
@app.route('/')
def hello():
return "hello docker"
if __name__=="__main__":
app.run(host='0.0.0.0',port=8080)

2.准备Dockerfile (名字必须叫做 Dockerfile)

touch Dockerfile ,写入如下内容

[root@VM_32_137_centos s21docker]# cat Dockerfile
FROM centos
COPY CentOS-Base.repo /etc/yum.repos.d/
COPY epel.repo /etc/yum.repos.d/
RUN yum clean all
RUN yum install python-setuptools -y
RUN easy_install flask
COPY s21flask.py /opt/
WORKDIR /opt
EXPOSE 8080
CMD ["python","s21flask.py"]

在Dockerfile同级目录,准备好其他环境文件,代码文件
[root@VM_32_137_centos s21docker]# ls
CentOS-Base.repo Dockerfile epel.repo s21flask.py

3.构建docker镜像
docker build -t yuchao163/s21-flask-docker .

docker build 编译Dockerfile
-t 给镜像加上名字 ,镜像名字,以仓库地址开头,则可以推送到仓库中管理
. 找到当前的Dockefile文件

4.构建完毕之后,查看镜像文件

docker images

5.运行这个flask镜像文件,生成容器实例,代码就跑在容器中了
docker run -d -p 5000:8080 指定你要运行的镜像id/名字

#推送本地镜像到dockerhub 共有仓库

1.登录docker账户
docker login

2.修改docker镜像文件名字,以docker hub账号开头

docker tag docker.io/hello-world yuchao163/s21-hello

3.推送镜像到dockerhub仓库中,(注意这个是公共仓库)

docker push yuchao163/s21-hello

#私有docker仓库搭建(保证镜像安全)

1.下载私有仓库镜像文件
docker run -d \
-p 5000:5000 \ # 宿主机的端口(自定义,自己考虑去分配):容器内暴露的端口(django中写了 8000),flask 5000
-v /opt/data/registry:/var/lib/registry \
registry

2.修改docker的配置文件,支持推送非https的私有镜像

修改docker的配置文件,
cat /etc/docker/daemon.json ,内容如下

{
"registry-mirrors": ["http://f1361db2.m.daocloud.io"],
"insecure-registries": [
"192.168.182.130:5000"
]
}

3.修改docker的启动文件,加载第二步,修改的配置文件

vim /lib/systemd/system/docker.service #找到如下的[Service] 代码块,添加参数

[Service]

EnvironmentFile= -/etc/docker/daemon.json

4.修改了docker配置文件，重新加载docker
systemctl daemon-reload

5.重启docker服务

systemctl restart docker

6.由于重启了docker,需要重新运行私有仓库的容器进程

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

--privileged=true docker容器的安全机制：设置特权级运行的容器

1042 docker pull 192.168.182.130:5000/s21-666-hello
1043 docker run 192.168.182.130:5000/s21-666-hello

rabbitmq消息队列的安装使用

1.yum安装即可

yum install erlang rabbitmq-server -y

2.启动rabbitmq服务端

systemctl start rabbitmq-server

3.配置rabbitmq,创建管理用户以及后台管理页面

sudo rabbitmqctl add_user pengpeng 123

4.给新用户,设置管理员角色
sudo rabbitmqctl set_user_tags pengpeng administrator

5.给与这个用户,对所有的队列,可读可写
语法:set_permissions [-p <vhostpath>] <user> <conf> <write> <read>

sudo rabbitmqctl set_permissions -p "/" pengpeng ".*" ".*" ".*"

6.添加rabbtimq管理界面
rabbitmq-plugins enable rabbitmq_management

7.访问mq的管理界面
http://123.206.16.61:15672/
服务器id:15672

8.登录rabbitmq服务端

9.练习rabbitmq的消息生产消费

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

消费者.py

import pika
# 建立与rabbitmq的连接
credentials = pika.PlainCredentials("pengpeng","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61',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)

# 开始消费，接收消息
channel.start_consuming()

10.单生产者,单消费者

执行服务端代码,生成队列,写入消息
执行消费者代码,从队列中取走消息

11.单生产者,多消费者 ,默认是轮询消费机制

12.消息丢列之确认机制,保证消息正确被处理 rabbitmq的ack确认机制

生产者代码不变
#!/usr/bin/env python
import pika
# 创建凭证，使用rabbitmq用户密码登录
# 去邮局取邮件，必须得验证身份
credentials = pika.PlainCredentials("pengpeng","123")
# 新建连接，这里localhost可以更换为服务器ip
# 找到这个邮局，等于连接上服务器
connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61',credentials=credentials))
# 创建频道
# 建造一个大邮箱，隶属于这家邮局的邮箱，就是个连接
channel = connection.channel()

# 新建一个hello队列，用于接收消息
# 这个邮箱可以收发各个班级的邮件，通过
channel.queue_declare(queue='西游记')
# 注意在rabbitmq中，消息想要发送给队列，必须经过交换(exchange)，初学可以使用空字符串交换(exchange='')，它允许我们精确的指定发送给哪个队列(routing_key=''),参数body值发送的数据
channel.basic_publish(exchange='',
routing_key='西游记',
body='大师兄,师傅被妖怪抓走了')
print("已经发送了消息")
# 程序退出前，确保刷新网络缓冲以及消息发送给rabbitmq，需要关闭本次连接
connection.close()

消费者代码如下.py

import pika

credentials = pika.PlainCredentials("pengpeng","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61',credentials=credentials))
channel = connection.channel()

# 声明一个队列(创建一个队列)
channel.queue_declare(queue='西游记')

def callback(ch, method, properties, body):
print("消费者接受到了任务: %r" % body.decode("utf-8"))
int('asdfasdf')
# 我告诉rabbitmq服务端，我已经取走了消息
# 回复方式在这,告诉服务端,我正确消费了消息,你可以标记清除了
ch.basic_ack(delivery_tag=method.delivery_tag)

# 关闭no_ack，代表给与服务端ack回复，确认给与回复
channel.basic_consume(callback,queue='西游记',no_ack=False)

channel.start_consuming()

13.消息和队列持久化
生产者代码.py

import pika
# 无密码
# connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61'))
# 有密码

credentials = pika.PlainCredentials("pengpeng","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61',credentials=credentials))
channel = connection.channel()

# 声明一个队列(创建一个队列)
# 默认此队列不支持持久化，如果服务挂掉，数据丢失
# durable=True 开启持久化，必须新开启一个队列，原本的队列已经不支持持久化了
'''
实现rabbitmq持久化条件
delivery_mode=2
使用durable=True声明queue是持久化

'''
channel.queue_declare(queue='python',durable=True) #这里实现队列创建的时候,就是持久化的

channel.basic_publish(exchange='',
routing_key='python', # 消息队列名称
body='life is short,i use python ',
# 支持数据持久化
properties=pika.BasicProperties(
delivery_mode=2,#代表消息是持久的 2
)
)
connection.close()

消费者代码.py

import pika
credentials = pika.PlainCredentials("pengpeng","123")
connection = pika.BlockingConnection(pika.ConnectionParameters('123.206.16.61',credentials=credentials))
channel = connection.channel()
# 确保队列持久化
channel.queue_declare(queue='python',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='python',no_ack=False)
channel.start_consuming()

1.saltstack软件学习

环境准备

1.准备3台机器
192.168.182.134 minion
192.168.182.133 minion
192.168.182.132 master

2.本地hosts文件做好强制解析(salt通过主机名通信更好管理,且通信更快)
cat /etc/hosts 内容如下,在三台机器上都得配置

192.168.182.134 s21minion1
192.168.182.132 s21minion2
192.168.182.133 s21master

3.master和minion 分别需要安装不同的软件包

master上:
yum install salt-master -y

minions上:
yum install salt-minion -y

4.修改salt-master以及salt-minion的配置文件

master修改如下

[root@s21master ~]#cat /etc/salt/master
interface: 0.0.0.0
publish_port: 4505
user: root
worker_threads: 5
ret_port: 4506
pidfile: /var/run/salt-master.pid
log_file: /var/log/salt/master

minion2配置修改如下

[root@s21minion2 ~]# cat /etc/salt/minion
master: s21master #填写master的主机名,
master_port: 4506 #填写master接收响应的端口号
user: root #以root执行
id: s21minion2 #这个id是,master在管理minion界面中,显示的名字
acceptance_wait_time: 10
log_file: /var/log/salt/minion

minion1配置修改如下

[root@s21minion1 ~]#cat /etc/salt/minion

master: s21master
master_port: 4506
user: root
id: s21minion1
acceptance_wait_time: 10
log_file: /var/log/salt/minion

5.分别启动minion和master

systemctl start salt-master
systemctl start salt-minion

6.通过秘钥检查,master是否管理了 minion

salt-key -L #列出master管控的所有key信息

7.检查master上的秘钥和minion是否一致

master上敲打: salt-key -f s21minion1

minion上敲打 : salt-call --local key.finger

8.在master上接收,所有的秘钥
salt-key -A #接收所有未被管控的秘钥

9.salt的第一个命令,验证minion机器是否存活

salt "*" test.ping

10.列出salt命令的详细信息

yaml配置文件语法解释

python 表示一个数据结构

{
"s21": {
"男同学":["老王","大郎","小红"],
"女同学":["大长腿","二长腿"]
}
}

yaml语法表示如下:
http://www.bejson.com/validators/yaml_editor/

"s21":
"男同学":
- "老王"
- "大郎"
- "小红"
"女同学":
- "大长腿"
- "二长腿"

posted @ 2019-09-22 16:15 AnthonyWang 阅读(126) 评论(0) 收藏举报

刷新页面返回顶部