一、阿里云部署常用的工具
1、目前阿里云推出了“轻量应用服务器”和”云服务器ESC”两款服务器
两款服务器具体操作差不多,购买时选择centos 系统，毕竟基于Linux系统，性能好；购买服务器后，两个重要的操作就是设置防火墙和镜像加速器（提高工具下载速度）。
设置防火墙，打开提供外部访问的端口：
设置阿里云镜像加速器，复制代码到系统内运行即可：
推荐几款好用的远程操控阿里云的SSH工具：
2、**yum:**
是redhat, centos 系统下的软件安装方式，基于Linux，全称为 Yellow dog Updater, Modified，是一个在Fedora和RedHat以及CentOS中的Shell前端软件包管理器基于RPM包管理，能够从指定的服务器自动下载RPM包并且安装，可以自动处理依赖性关系，并且一次安装所有依赖的软件包
3、Linux下常用指令：
创建：
创建文件： mkdir
创建多级文件夹：mkdir -p
创建文件： touch
chmod -R 777 权限目录
export LANG=zh_CN.gbk ssh中文乱码
/etc/locale.conf 中添加 LANG=zh_CN.gbk 执行
source /etc/locale.conf 乱码问永久解决
ip addr 查看ip删除：
rm -f 删除文件
rm -rf 删除文件夹和它下面的所有文件
echo ""> 清空文件内容拷贝：
cp 移动单个文件
cp -r 移动文件夹下的所有文件
mv 复制粘贴端口：
1、强制杀死该端口进程
fuser -k -n tcp 80
2、根据PID关闭某个被占用的端口
netstat -tunlp | grep 80
lsof -i:80
sudo kill -9 PID
启动指令:service iptables start
重启指令:service iptables restart
关闭指令:service iptables stop
/sbin/iptables -I INPUT -p tcp --dport 8011 -j ACCEPT #开启8011端口
/etc/rc.d/init.d/iptables save #保存配置
/etc/rc.d/init.d/iptables restart #重启服务
禁用防火墙
[root@rhel7 ~]# systemctl stop firewalld.service
[root@rhel7 ~]# systemctl disable firewalld.service
[root@rhel7 ~]# systemctl status firewalld.service
systemctl start firewalld.service 开启
systemctl enable firewalld.service 开机启动防火墙
只允许IP访问端口
iptables -A INPUT -p tcp --dport 9200 ! -s 127.0.0.1 -j DROP
添加
firewall-cmd --zone=public --add-port=80/tcp --permanent （--permanent永久生效，没有此参数重启后失效）
重新载入
firewall-cmd --reload
查看
firewall-cmd --zone=public --query-port=80/tcp
删除
firewall-cmd --zone=public --remove-port=80/tcp --permanent4、阿里云部署docker
1、查看系统(docker)内核版本：uname -r
2、查看系统配置：cat /etc/os-release
3、显示docker版本信息：docker version
4、显示docker系统信息、包括镜像和容器数量：docker info
5、docker帮助命令：docker 命令 --help
1、包更新到最新：yum update
2、yum -y install yum-utils安装需要的软件包，yum-utils提供yum-config-manager功能，另外两个是devicemapper驱动依赖的：
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、安装docker：yum install docker-ce
5、安装后查看docker版本：docker -v
6、docker常用命令：
启动docker：
systemctl start docker
停止docker：
systemctl stop docker
重启docker：
systemctl restart docker
查看docker状态：
systemctl status docker
开机启动：
systemctl enable docker
查看运行的容器
docker ps
查看所有容器包括没运行的
docker ps -a
搜索镜像
docker search image
拉取镜像
docker pull mysql
查看镜像
docker images
删除镜像
docker image rmi -f 镜像id #删除指定镜像
docker image rmi -f 镜像id 镜像id 镜像id #删除多个镜像
docker image rmi -f $(docker images -aq) #删除全部镜像
推出容器
exit #直接容器停止并退出
Ctrl+P+Q #容器不停止退出
删除容器
docker rm 容器id #删除指定容器，不能删除正在运行的
docker rm -f $(docker ps -aq) #删除全部容器，包括运行的
docker ps -a -q|xargs docker rm #删除全部容器
启动和停止容器
docker start 容器id #启动容器
docker restart 容器id #重启容器
docker stop 容器id #停止当前正在运行的容器
docker kill 容器id #强制停止当前容器
#1、后台启动容器：
1、命令：docker run -d 镜像名
docker run -d mysql
2、问题：docker ps，发现mysql停止了，为什么？
docker容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止。（docker run -it mysql bash）
#2、查看日志：
--tf #显示全部日志（docker logs --help查看）
--tail number #显示日志条数
docker logs -tf --tail 10 容器id
#3、查看容器中的进程信息：
docker top 容器id
#4、查看镜像的元数据：
docker inspect 容器id
#5、进入当前正在运行的容器：
#方式一（进入容器后开启一个新的终端，可以在里面操作）
docker exec -it 容器id bash
#方式二（进入容器正在执行的终端，不会启动新的进程）
docker attach 容器id
#6、从容器内拷贝文件到主机上：
docker cp 容器id：容器内路径 目的的主机路径
#步骤：
docker exec -it mysql bash #进入容器
cd /home #进入容器home文件夹
touch test.java #在容器home文件夹创建test.java文件
ls #查看创建的test.java文件
exit #退出容器
docker cp mysql:/home/test.java /home #拷贝文件到主机home文件夹下
cd /home #进入主机home文件夹
ls #即可查看是否拷贝test.java成功
#运行docker：
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
常用选项说明
-d, --detach=false， 指定容器运行于前台还是后台，默认为false
-i, --interactive=false， 打开STDIN，用于控制台交互
-t, --tty=false， 分配tty设备，该可以支持终端登录，默认为false
-u, --user=""， 指定容器的用户
-a, --attach=[]， 登录容器（必须是以docker run -d启动的容器）
-w, --workdir=""， 指定容器的工作目录
-c, --cpu-shares=0， 设置容器CPU权重，在CPU共享场景使用
-e, --env=[]， 指定环境变量，容器中可以使用该环境变量
-m, --memory=""， 指定容器的内存上限
-P, --publish-all=false， 指定容器暴露的端口,随机映射端口
-p, --publish=[]， 指定容器暴露的端口
-h, --hostname=""， 指定容器的主机名
-v, --volume=[]， 给容器挂载存储卷，挂载到容器的某个目录
--volumes-from=[]， 给容器挂载其他容器上的卷，挂载到容器的某个目录
--cap-add=[]， 添加权限，权限清单详见：http://linux.die.net/man/7/capabilities
--cap-drop=[]， 删除权限，权限清单详见：http://linux.die.net/man/7/capabilities
--cidfile=""， 运行容器后，在指定文件中写入容器PID值，一种典型的监控系统用法
--cpuset=""， 设置容器可以使用哪些CPU，此参数可以用来容器独占CPU
--device=[]， 添加主机设备给容器，相当于设备直通
--dns=[]， 指定容器的dns服务器
--dns-search=[]， 指定容器的dns搜索域名，写入到容器的/etc/resolv.conf文件
--entrypoint=""， 覆盖image的入口点
--env-file=[]， 指定环境变量文件，文件格式为每行一个环境变量
--expose=[]， 指定容器暴露的端口，即修改镜像的暴露端口
--link=[]， 指定容器间的关联，使用其他容器的IP、env等信息
--lxc-conf=[]， 指定容器的配置文件，只有在指定--exec-driver=lxc时使用
--name=""， 指定容器名字，后续可以通过名字进行容器管理，links特性需要使用名字
--net="bridge"， 容器网络设置:
bridge 使用docker daemon指定的网桥
host //容器使用主机的网络
container:NAME_or_ID >//使用其他容器的网路，共享IP和PORT等网络资源
none 容器使用自己的网络（类似--net=bridge），但是不进行配置
管理卷
# docker volume create edc-nginx-vol // 创建一个自定义容器卷
# docker volume ls // 查看所有容器卷
# docker volume inspect edc-nginx-vol // 查看指定容器卷详情信息
# docker volume rm edc-nginx-vol // 删除自定义数据卷
# docker inspect edc-nginx5、docker 部署MySQL
1、拉取mysql（可设置拉取镜像版本号）：docker pull mysql:5.7
2、运行容器：
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名
#不带数据卷：
docker run --name mysql -p 3306:3306
-e MYSQL_ROOT_PASSWORD=1234 -d mysql
#带数据卷(容器和主机数据同步，保证数据不丢失)：
docker run --name mysql -p 3306:3306 \
-v /home/mysql/conf:/etc/mysql/conf.d \
-v /home/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root -d mysql:5.6
3、进入容器：docker exec -it mysql5.7 bash
4、进入mysql：mysql -uroot -p
5、选择一个数据库：use mysql
6、修改加密方式（MYSQL8需要）：alter user 'root'@'localhost' identified with mysql_native_password by 123456';
7、查看加密方式：select host,user,plugin from user;
8、开启远程：GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '1234' WITH GRANT OPTION;
9、刷新权限：flush privileges;6、docker部署tomcat
#官方的使用(docker run -it --rm,一般用来测试，用完就删除)
docker run -it --rm tomcat:9.0
#下载后使用
1、拉取镜像：docker pull tomcat
2、启动：docker run --name tomcat -p 8080:8080 -d tomcat
3、查看tomcat安装在哪儿：whereis tomcat
4、进入容器：docker exec -it tomcat bash
5、查看(发现webapps文件里没有东西，镜像的原因，官方默认webapps里没有文件，webapps.dist文件里有)：ls
6、复制webapps.dist内所有文件到webapps即可：
cp -r webapps.dist/* webapps
7、访问：阿里云IP+8080外部端口
8、查看端口号是否被占用：netstat -anp |grep 8080
9、访问部署端口号是否成功：crul localhost:80807、docker部署nginx
1、拉取nginx：docker pull nginx
2、查看镜像：docker images nginx
3、启动：docker run --name cade-nginx-test -p 8081:80 -d nginx
4、访问：阿里云IP地址+8081端口号
5、部署（创建nginx目录，三个子文件夹www、logs、conf）：
mkdir -p ~/nginx/www ~/nginx/logs ~/nginx/conf
6、拷贝容器内nginx默认配置文件到本地当前目录下的conf目录：
docker cp d21ec270e7f3:/etc/nginx/nginx.conf ~/nginx/conf
7、进入拷贝文件夹：cd nginx/conf
8、查看nginx.conf文件：cat nginx.conf
9、部署：
docker run -d -p 8082:80 --name cade-nginx-test-web -v ~/nginx/www:/usr/share/nginx/html -v ~/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v ~/nginx/logs:/var/log/nginx nginx
10、写个测试页面：
进入www文件夹：cd nginx/www
写一个index.html文件：vim index.html
写个html：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>my nginx</title>
</head>
<body>
<h1 style="color:red">你好！我是nginx服务器</h1>
<img src="img/1.jpg"/>//img文件夹也放于www文件夹下
</body>
</html>
11、访问部署好的网页：阿里云IP地址+8082端口号8、docker部署es（elasticsearch）+kibana
#首先知道：
es暴露的端口很多，
es十分耗内存，
es的数据需要放置到安全目录
#--net somenetwork 表示网络配置
1、启动elasticsearch：
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.10.1
2、查看cpu状态(可知es相当占内存)：docker stats
3、因此增加内存限制，修改配置文件(-e 环境配置修改)：
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.10.1 kibana如何连接es？
9、管理镜像和容器的可视化工具
#工具1：portainer（提供操控的面板）
1、什么是portainer？
它是docker的图形化界面管理工具，提供一个后台面板供我们操作！
2、部署portainer：
docker run -d -p 8089:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
3、访问：阿里云IP+8089外网端口
4、设置秘密
5、选择本地（local）
6、查看
---------
#工具2（CI/CD）：Rancher(持续集成和持续部署使用)10、commit 镜像
#命令：
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[tag]
#上面部署tomcat时候webapps里面没有文件，经过我们从webapps.dist里面复制文件到webapps里面，外网就可以访问前端数据了，现在我们把我么自己修改的tomcat提交：
docker commit -m="add webapps app" -a="xiaolu" 6e0af437ec7c tomcat01:1.0
#输入命令（即可查看自己提交的tomcat01）：
docker images
11、容器数据卷
#什么是容器数据卷？
将应用和环境打包放在容器里面，如果我们不小心把容器删除了，那么我们打包好的数据也会丢失；为了使数可以持久化（好比部署了一个mysql容器，里面有数据库，有人删了容器，不就删库跑路了吗，数据库里面的数据全部丢失了！），容器数据卷提供了一个容器之间可以数据共享的技术（docker容器中产生的数据，同步到本地；也就是目录的挂载，将我们容器内的目录，挂载到Linux上面！）
#总结：
容器的持久化和同步操作；容器间也是可以数据共享的！
#方式一：直接使用命令 -v 来挂载（指定宿主机目录）
命令：docker run -it -v 主机目录：容器目录 容器名 /bin/bash
形如：docker run -it -v /home/a:/home/a mysql bash
查看挂载情况（如下图）：docker inspect 容器id
数据同步操作：在主机a文件夹下或在容器a文件夹下建立一个文件（touch test.java）,进入对应的容器文件夹或主机文件夹，都能看见建立的文件，说明保证了数据的同步和持久化 ；同样关闭容器的同时，对主机上test.java的修改，也会同步到容器（即容器里面的test.java同步改变）
容器数据卷带来的好处：修改本地主机上的文件即可，容器内会自动同步
#方式二：dockerfile
1、什么是Dockerfile？
用来构建docker镜像的构建文件，一段命令脚本（通过这个脚本可以生成镜像），启动执行即可
2、体验：
2-1:创建一个dockerfile文件，名字可以随意
形如：FROM nginx
VOLUME ["volume01","volume02"]
CMD echo "----end----"
CMD /bin/bash
上面的四个命令，每个命令就是镜像的一层
2-2:构建镜像
命令:docker build -f dockerfile -t lujiahong/nginx:1.0 .
2-3:查看镜像
命令:docker images
2-4:启动自己构建的镜像
命令:docker run -it 镜像id /bin/bash
可以看到自动挂载的数据卷目录：volume01和volume02
进入volume01文件夹创建文件：touch test.java
2-5：明确volume01和volume02 是匿名挂载
查看自己构建的镜像id：docker ps
查看镜像元数据（如下图）：docker inspect 镜像id
进入volume01目录：cd/var/lib/docker/volumes/
4febd1f8e1a4d4c282095ebf743b59cabe0a3e7d6782d02e3b20d599df5f0684/_data
查看文件（可看见同样有文件test.java,说明通过dockerfile也能实现数据同步）：ls
#数据卷容器之间实现数据同步
1、实现方式：
形如：多个mysql实现数据同步
2、体验：
通过上面构建的镜像（lujiahong/nginx:1.0）来创建两个（多个，其中一个为主容器，其它容器需要去继承这种关系，实现数据同步）容器
#创建主容器：
命令：docker run -it --name 主容器名 镜像id /bin/bash
形如：docker run -it --name nginx_test01 ee0c211759f7 bash
#创建子容器：
命令：
docker run -it --name 子容器名1 --volumes-from 主容器名 镜像id
形如：
docker run -it --name nginx_test2 --volumes-from nginx_test1 ee0c211759f7
3、测试
进入主容器的目录volume01里面创建文件：touch test.txt
进入子容器的目录volume01里面查看文件: ls
4、结果
子容器volume01文件夹下有test.txt文件，能够实现容器间数据同步；
即使主容器停掉或者删除，子容器仍然可以访问以前创建的文件；
子容器和主容器通过命令：--volumes-from来同步共享卷；
5、结论
容器之间配置信息的传递，数据卷容器一直持续到没有容器使用为止；
但是一旦你通过-v持久化到了本地，那么本地的数据是不会被删除的；12、具名和匿名挂载
#具名挂载（通过 -v 指定名字）
命令：docker run -d -P --name 容器名 -v 卷名：/etc/镜像名 镜像名
形如：
docker run -d -P --name nginx01 -v nginx_ok:/etc/nginx nginx
查看卷：docker volume ls
查看卷挂载目录：docker volume inspect nginx_ok
查看volumes文件夹下的卷：cd var/lib/docker/volumes
查看_data文件夹（可看见nginx.conf）:cd nginx_ok/_data
#结论：
所有docker容器内的卷，没有指定目录的情况下都是在：
var/lib/docker/volumes/卷名/_data
通常使用的就是具名挂载，方便找到卷
#匿名挂载（没有卷名，是一长字符串，不好找，不采用建议）
命令：docker run -d -P --name 容器名 -v /etc/镜像名 镜像名
#如何区分 具名挂载、匿名挂载和指定路径挂载？
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径:容器内路径 #指定路径挂载
#拓展
ro表示：readonly #只读，说明这个路径只能通过宿主机来操作，容器内部无法操作了
rw表示：readwrite #只写
docker run -d -P --name 容器名 -v 卷名：/etc/镜像名:ro 镜像名
docker run -d -P --name 容器名 -v 卷名：/etc/镜像名:rw 镜像名
13、关于DockerFile
dockerfile是用来构建docker镜像的文件！命令参数脚本！
#构建步骤：
1、编写一个dockerfile文件；
2、docker build 构建成一个镜像；
3、docker run 运行镜像；
4、docker push 发布镜像（DockerHub、阿里云镜像仓库）
#dockerfile文件构建过程：
1、每个保留关键字（指令）都必须是大学字母
2、执行顺序从上到下
3、#表示注释
4、每一个指令都会创建提交一个新的镜像层，并提交
#结论（开发->部署->运维）：
1、dockerfile(构建文件，定义了一切的步骤，源代码):是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单！
2、dockerImages(通过dockerfile构建生成的镜像，最终发布和运行的产品):逐渐成为企业交付的标准，必须要掌握！
3、dockerContainer(容器就是镜像运行起来提供的服务)以前我们使用别人的镜像，现在我们通过dockerfile来构建自己的镜像！
#dockerfile指令
FROM #基础镜像，一切从这里开始
MAINTAINER #镜像是谁写的（姓名+邮箱）
RUN #镜像构建的时候需要运行的命令
ADD #添加你构建镜像所需的压缩包（tomcat、redis..）
WORHDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #暴露端口配置
CMD #指定这个容器启动时要运行的命令，只有最后一个会生效，可被替换
ENTRYPOINT #指定这个容器启动时要运行的命令，可以追加命令
COPY #类似ADD命令，将文件拷贝到镜像中
ENV #构建时候设置环境变量
ONBUILD #当构建一个被继承dockerfile，这个时候就会运行ONBUILD的指令（被触发，为触发指令），
实战，写一个dockerfile
#明确
1、创库 DockerHub中 99%镜像都是从这个基础镜像（FROM scratch）过来的，然后配置需要的软件和配置来进行构建的；
创键一个自己的centos
1、编写dockerfile文件（dockerfile-centos）：
FROM centos
MAINTAINER lujiahong<2275435926@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash
2、通过这个文件构建镜像
命令：docker build -f dockerfile文件路径 -t 构建的镜像名:版本号 .
形如：docker build -f dockerfile-centos -t mycentos:1.0 .
输出：Successfully built 7a57298bfce2
Successfully tagged mycentos:1.0
3、测试
命令：docker run -it mycentos:1.0 bash
结果：根目录变为了/usr/local
能够执行ifconfig、vim、ls等命令了 （相比于原生的centos）
查看镜像的历史：docker history 镜像idCMD 和 ENTRYPOINT 指令区别
CMD #指定这个容器启动时要运行的命令，只有最后一个会生效，可被替换
ENTRYPOINT #指定这个容器启动时要运行的命令，可以追加命令#测试CMD
1、查看构建的dockerfile（dockerfile-cmd-test）：
命令：cat dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]
2、构建镜像：
命令： docker build -f dockerfile-cmd-test -t cmd-test:1.0 .
Successfully built dd377d081f6c
Successfully tagged cmd-test:1.0
3、启动镜像（dd377d081f6c），发现CMD中定义的ls和-a命令生效：
命令： docker run dd377
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
。。。。
4、执行追加的命令 -l，想要（ls -al），但发现报错
命令：docker run dd377 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:370: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
原因：CMD的情况下，-l替换了["ls","-a"]命令，-l不是命令，所以报错；然而这种情况用ENTRYPOINT命令可以解决实战:dockerfile创建tomcat镜像
1、准备镜像文件(dockerfile)和压缩包(tomcat和jdk)
#进入MyImages文件夹
1、下载tomcat的tar.gz
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.43/bin/apache-tomcat-9.0.43.tar.gz
2、下载jdk的tar.gz
wget https://www.oracle.com/webapps/redirect/signon?nexturl=https://download.oracle.com/otn/java/jdk/11.0.10%2B8/020c4a6d33b74f6a9d2bc6fbf189da81/jdk-11.0.10_linux-x64_bin.tar.gz
3、编写Dockerfile文档
vim Dockerfile
4、编写readme.txt说明文档
touch readme.txt
2、编写dockerfile文件
FROM centos
MAINTAINER lujiahong<2275435906@qq.com>
COPY readme.txt /usr/local/readme.txt
ADD apache-tomcat-9.0.43.tar.gz /usr/local/
ADD jdk-8u241-linux-x64.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_241
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.43
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.43
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.43/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.43/bin/logs/catalina.out3、构建镜像
#执行命令（由于官方命名就是Dockerfile文件，因此这里构建镜像时不用-f 指定文件路径）：docker build -t mytomcat .
Successfully built 4fada7bd13fd
Successfully tagged mytomcat:latest
4、运行镜像
#运行镜像，并和宿主机路径挂载，实现数据(测试和日志)同步
docker run -d -p 8080:8080 --name LJH-tomcat -v /home/MyImages/test:/usr/local/apache-tomcat-9.0.43/webapps/test -v /home/MyImages/logs:/usr/local/apache-tomcat-9.0.43/logs mytomcat
5、访问测试
#方式一
curl localhost:9090
#方式二
http://阿里云ip地址 + 9090端口6、发布项目（由于做了卷挂载，我们直接在本地编写项目就可以发布了！）
#test文件夹下 需要个WEB-INF文件夹(里面需要有web.xml)和index.jsp文件(或者html)
1、web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
</web-app>
2、index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>mytomcat-test</title>
</head>
<body>
Hello!this is LJH-tomcat<br/>
<%=request.getRemoteAddr());
%>
</body>
</html>7、发布自己的镜像（DockerHub或者阿里云）
#发布镜像到DockerHub
1、注册账号并登录（https://hub.docker.com/）
docker login -u 用户名 -p 密码
2、在我们的服务器上提交自己的镜像
docker push 镜像名：版本号
#不能提交自己镜像怎么解决，那么肯定是镜像名重复l
docker tag 镜像id 新镜像名：版本号
#那么再来提交
docker push 新镜像名：版本号
#发布到阿里云镜像服务器
1、登录阿里云
docker login --username=ljh130168 registry.cn-shanghai.aliyuncs.com
2、找到容器镜像服务
3、创建命名空间
4、创建容器镜像
5、点开容器镜像
最后张图片，可知给我们提供了发布镜像的步骤
6、提交镜像
docker tag [ImageId] registry.cn-shanghai.aliyuncs.com/lujiahong/lujiahong:[镜像版本号]
docker push registry.cn-shanghai.aliyuncs.com/lujiahong/lujiahong:[镜像版本号]
Dockerfile小结
14、docker网络
docker0
好比说现在部署了一个项目在docker上面，那么容器tomcat是如何访问到容器mysql里面的数据的呢（容器网络访问）？这就是docker网络探讨的问题
#理解docker0
命令：ip addr
结果：
可以得到三个网络：
lo #本机回环地址
eth0 #阿里云内网地址
docker0 #docker0地址
探讨：docker是如何处理容器网络访问的？
步骤：
1、启动一个容器：docker start 容器id
2、查看容器ip：docker exec -it 容器id ip addr
3、再查看主机ip：ip addr
4、对比2和3的ip发现：成对出现，采用evth-pair技术
结论：
我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只需要安装了docker，就会有一个docker0（采用桥接模式，使用的技术是evth-pair技术）
evth-pair技术：
evth-pair就是一对的虚拟设备接口，它们都是成对出现，一段连着协议，一段彼此相连；正因有这个特性，evth-pair充当一个桥梁（按道理Linux主机上是不能ping通分配给容器的ip，正因这个桥梁就可以ping通了；同样依靠evth-pair技术，容器之间也可以ping通了），连接各种虚拟网络设备；使用evth-pair技术的有（Openstac、OVS连接、Docker容器之间连接）
#思考容器与容器之间能够ping通的原理？
实际上采用的还是evth-pair技术。但容器之间的访问，不是两者之间的直接访问，而是通过docker0（相当于路由器，有路由表等）依赖evth-pair技术实现容器之间的访问，如下图
#结论：
1、所有的容器在不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认可用的IP；
2、Docker中所有的接口都是虚拟的，虚拟的转化效率高；
3、只要容器删除，依赖evth-pair技术的网桥一对就没了；
#docker0的特点：
1、默认的网络模式（bridge）；
2、域名（容器名）不能访问，--link可以打通连接；
–link
#思考:
上面容器与容器之间ping通是通过docker0分发给容器的IP地址,那么除了IP地址能够ping通外,还可以通过--link在运行时候指定容器名,然后通过容器名ping通来实现容器之间的访问,如下图:
命令:docker run -it --name 容器名 --link 另一个建立好的容器名 镜像
命令：docker exec -it 容器名 ping 另一个建立好的容器名
命令：docker exec -it 容器名 cat /etc/hosts
#结论：
1、--link本质就是在hosts里面配置本地绑定(容器之间映射)；
2、通过--link通过容器名来ping通适合于初学者，企业都采用自定义网络；
3、docker0是官方的网桥，支持容器之间IP连接访问，但不支持容器之间容器名（--name 容器名）连接访问，而自定义网络可以实现，我们可以自定义一个网络支持容器名连接访问即可。自定义网络
#查看所有的网络：
docker network ls
#有哪些网络模式？
1、桥接模式(bridge),说白了就是在docker上进行搭桥,docker默认模式
2、不配置网络(none)
3、和宿主机共享网络(host)
4、容器内网络连通(container)
#测试
#--net bridge这个可以不写，默认桥接模式，也就是的docker0；通过--net可以更改网络或者自定义网络
docker run -d -P --name test-nginx --net bridge nginx
#自定义网络
#--driver bridge （定义网络模式为桥接模式）
#--subnet 192.168.0.0/16（子网：192.168.0.2~192.168.255.255）
#--gateway 192.168.0.1 （定义网关，也就是路由默认ip）
#mynet （自定义网络名）
创建自定义网络命令：
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
查看自定义网络命令：
docker inspect mynet
#把服务放在自定义网络mynet里面
#启动两个容器，再查看
命令： docker run -d -P --name test-nginx --net mynet nginx
命令：docker run -d -P --name test-nginx-01 --net mynet nginx
命令：docker inspect mynet 
#通过容器名（域名）来实现容器之间的访问
命令：docker exec -it test-nginx ping test-ngix-01
#结论：
1、采用自定义网络无需通过--link来指定容器之间映射关系，这种关系已经维护好了；
2、在做redis集群和mysql集群的时候，不同集群使用不同的网络，保证了集群是安全和健康的；那么不同集群使用的不同的网络，则需要认知网络连通；
网络连通
#通过docker network connet来实现不同网络的连通
#通过docker network --help查找到connet命令
#通过docker network connet --help连接connet的用法
现在已经有默认网络docker0和自定义网络mynet，现在如何实现两个网络下的容器相互访问；docker0下有容器tomcat-test，mynet下有容器tomcat01和tomcat02；连通指定网络和容器名即可实现网络连通
命令：docker network connet mynet tomcat-test
命令：docker inspect mynet
命令：docker exec -it tomcat-test ping tomcat01
#结论：
>实战：部署Redis集群
#shell脚本
1、创建网卡
docker network create redis --subnet 172.38.0.0/16
2、通过脚本创建六个redis配置
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat <<EOF>>/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v/mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
done
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
3、创建集群（docker exec -it redis-1 sh）
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
4、测试
redis-cli #单机
redis-cli -c #集群
cluster info #查看集群信息
cluster nodes #查看集群节点
#分析：
所搭建的集群是三主三从。实现高性能、高可用和负载均衡
5、测试高可用
命令：set key value
命令：get key
当存入的时候找到存入的服务ip，然后停止服务，再取数据，会发现是从从redis里面获取到的数据。实现了高可用(关闭存入的主redis，相当于故障转移，和它数据同步的从redis会替换它成为主redis，如下图)
SpringBoot微服务打包Docker镜像
#步骤
1、构架springboot项目
2、打包应用
3、编写dockerfile
4、构建镜像
5、发布运行15、docker Compose
16、docker Swarm及k8s
17、CI/CD之Jenkins
二、基于一个Servlet部署到阿里云（war包）
1、安装java运行环境：yum install java
2、复制新版本tar.gz地址到,执行此命令下载：wget tar.gz地址
3、解压下载好的tomcat:tar -xzf apache-tomcat-9.0.22.tar.gz
4、进入解压好的文件夹：cd apache-tomcat-9.0.22
5、再进入里面的bin文件夹：cd bin
6、查看文件夹文件（有启动tomcat文件：startup.sh）：ls
7、启动tomcat:sh startup.sh
8、访问阿里云tomcat：阿里云IP地址+8080端口号，前提打开8080防火墙端口
9、三、部署一个项目（前后端）到阿里云
