一.学习Docker前的学习流程

java全栈：
    1.前端
    2.数据库
    3.javaweb
    4.框架
    5.spingcloud微服务
    6.常用技术栈
    7.分析开源项目
    8.Linux以及阿里云ECS部署

二.学前准备

1.Linux基础
2.springboot（可选）

三.Docker学习内容

1.Docker入门（单机版Docker搭建应用）
    <1>概述
    <2>安装
    <3>命令:镜像命令，容器命令，操作命令...（类比于java的关键字）
    <4>Docker镜像
    <5>容器的数据卷:因为Docker和服务器与数据库是互相隔离的
    <6>DockerFile:把微服务项目构建成镜像
    <7>Docker网络原理
    <8>IDEA怎么整合Docker
2.Docker进阶(企业级Docker)
    <1>Docker Compose：处理集群,做编排
    <2>Docker Swarm:管理集群
    <3>CI/CD:如jenkins的流水线
     

四.是什么

1.Docker的历史

 不懂历史，只算是会使用api的初级开发工程师 ；
 2010年，一个小团队最开始成立的公司是dotCloud，处理pass的云计算服务（类似于VM做的事情，用了容器化技术），他们后来把容器化技术命名为Docker，Docker刚出来的时候没有被关注，2013年团队就把Docker开源了，2014年4月9日，Docker1.0发布

2.体量小的特点

<1>虚拟化技术

虚拟机和Docker都是虚拟化技术，容器化技术出来之前，我们都是用虚拟机技术

<2>虚拟机

在windows中装一个Vmware，通过这个软件我们可以虚拟一台或多台电脑

<3>docker

容器化技术不是模拟一个完整的操作系统，比如安装一个centos7，只需要按照他的核心就够了，把所有东西打包隔离
只需要管软件就行了，体量比虚拟机小很多，他强调隔离和镜像（用最核心的环境，比如linux最低4m就够了，启动环境+jdk环境+mysql环境），只需要运行镜像就可以使用  

<4>虚拟机和容器化技术对比

传统虚拟机，需要虚拟出一套硬件，运行一套完整的操作系统，然后在操作系统上安装和运行软件
容器内的应用可以直接运行在宿主机上的内容，容器是没有内核的，不用虚拟出一套硬件系统，每个容器间互相隔离，每个容器内都有属于自己文件系统，互不影响

3.Docker基本组成

<1>Docker架构图

    用客户端启动docker里面的容器，这个容器再去数据仓库下载

<2>镜像（image）

I.是什么

i.docker的镜像好比是一个模板，可以通过这个模板创建容器服务
如Tomcat镜像：run=> tomcat01容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）
ii.用来打包软件运行环境和基于运行环境开发的软件，包含了运行某个软件所需的所有内容，包括代码，运行时，库，环境变量和配置文件

II.怎么用

i.远程仓库下载
ii.朋友拷贝给你
iii.自己制作镜像DockerFile

III.Docker镜像加载原理

UFS：联合文件系统

IV.分层理解

V.制作自己的镜像（commit）

<3>容器（container）

Docker利用容器化技术，可以独立运行一个或一组应用，通过镜像创建，
容器可以启动，删除，停止...基本命令
可以把容器当成一个简易的linux系统，项目就放在这个简易的linux系统上

<4>仓库（repository）

仓库是用来存放镜像的地方，好比自己的开源项目放在Github上一样
仓库分为共有仓库和私有仓库：（默认是国外的）
    Docker Hub（国外的）
    阿里云...都有容器服务器（需要配置镜像加速）

五.为什么用

1.之前发项目遇到的问题：

一款产品上线：开发->上线，需要两套环境，
开发 - - - 运维
环境配置十分麻烦，每一台机器都需要部署环境（集群Redis、ES、Hadoop...）,部署错了需要从头来
之前发布项目是发jar包或war包（需要部署Redis、Mysql、jdk、ES...环境），为了能够发jar包的时候带上环境，就出现了Docker
传统：开发打好jar包交给运维部署
现在：开发打包部署上线，一套流程完成

2.Docker给出的解决方案

针对开发和运维遇到的问题，Docker的解决方案是把环境和项目一起打包成镜像，然后通过互相隔离的机制就可以实现
<1>是什么
<2>为什么用
I.能够更快速的交付和部署应用
    传统：看帮助文档，安装程序
    Docker：打包镜像发布测试，一键运行
II.更便捷的升级和扩缩容
   使用Docker，部署应用就和搭积木一样，比如项目要升级的，想要换里面的环境（如Tomcat5 ——> Tomcat8）
   传统：很麻烦，需要联调
   Docker：把带着环境打包好的项目做升级，把jar包给运维就可以
III.更简单的系统运维
   使用容器化技术之后，开发和测试环境高度一致
IV.更高效的计算资源利用
   Docker是内核级别的虚拟化，不用像传统虚拟机一样需要管理程序的支持，可以满足一个物理机上可以运行多个容器实例
<3>怎么用

3.DevOps（开发运维）

六.怎么用

1.安装（默认工作路径：/var/lib/docker）

<1>环境准备

I.需要一点儿Linux基础
II.系统Centos7
III.使用xshell连接远程服务器

<2>系统版本查看

[root@userAlex /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
#centos7

<3>环境查看

 [root@userAlex /]# uname -r
 3.10.0-957.21.3.el7.x86_64
 #内核时3.10以上的
 

<4>.查看帮助文档进行安装

I.卸载旧版本

II.安装新版本

i.使用存储库安装

①.yum方式下载安装包：

 yum install -y yum-utils

②.设置镜像的仓库

I.国外的，很慢
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
II.推荐用国内的，阿里云Docker镜像地址
yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo       

③.更新yum软件包索引

yum makecache fast

④.安装Docker相关的源

yum install docker-ce docker-ce-cli containerd.io
# docker-ce 社区版本
# docker-ee 企业版

⑤.启动docker

systemctl start docker

⑥.查看是否成功安装

docker version

⑦.运行helloworld镜像，测试并分析流程

分析run helloworld流程：
执行docker run之后，docker做了什么事情，即docker run的运行原理
docker在本机寻找镜像，并判断本机有没有这个镜像，如果有就运行，如果没有就去阿里云加速上（Docker Hab太慢）远程下载；
远程仓库判断是否可以找到，找不到就返回找不到，找到了就下载镜像到本地        

⑧.查看helloworld镜像的位置

docker images    

⑨.卸载docker(卸载依赖，删除目录)

systemctl stop docker
    卸载 Docker 引擎、CLI 和 Containerd 软件包：
yum remove docker-ce docker-ce-cli containerd.io
    主机上的映像、容器、卷或自定义配置文件不会自动删除。要删除所有映像、容器和卷：
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

⑩.配置阿里云镜像加速

ii.离线安装

①下载arm架构对应安装包

Index of linux/static/stable/aarch64/
位置：/export/software

②压缩

tar -zxvf docker-18.06.3-ce.tgz -C /export/server

③复制docker下的二进制文件到/usr/bin

cp ./docker/* /usr/bin

④ 创建docker.service文件并编辑

  cd /etc/systemd/system/
  touch docker.service
  vim docker.service
  

#--insecure-registry=192.168.205.230改为自己ip
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
 
[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd --selinux-enabled=false --insecure-registry=172.16.205.137
ExecReload=/bin/kill -s HUP $MAINPID
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
# Uncomment TasksMax if your systemd version supports it.
# Only systemd 226 and above support this version.
#TasksMax=infinity
TimeoutStartSec=0
# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes
# kill only the docker process, not all processes in the cgroup
KillMode=process
# restart the docker process if it exits prematurely
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
 
[Install]
WantedBy=multi-user.target

⑤添加可执行权限

chmod +x docker.service

⑥加载docker.service（只要修改了该文件就需要再次加载）

systemctl daemon-reload

⑦启动docker并查看状态

systemctl start docker
systemctl status docker
docker -v

iii.一键安装和卸载脚本

①在docker-18.06.3-ce.tgz同目录下，创建docker.service，打开编辑文件，编辑上面一样的内容

②一键安装脚本

touch install.sh
vim install.sh

#!/bin/sh
 
echo '解压tar包'
tar -xvf $1
echo '将docker目录下所有文件复制到/usr/bin目录'
cp docker/* /usr/bin
echo '将docker.service 复制到/etc/systemd/system/目录'
cp docker.service /etc/systemd/system/
echo '添加文件可执行权限'
chmod +x /etc/systemd/system/docker.service
echo '重新加载配置文件'
systemctl daemon-reload
echo '启动docker'
systemctl start docker
echo '设置开机自启'
systemctl enable docker.service
echo 'docker安装成功'
docker -v

③找到docker-18.06.3-ce.tgz同目录下，还有上边创建的docker.service，install.sh，uninstall.sh这3个文件：分别给install.sh和uninstall.sh赋予可执行权限。

  chmod +x install.sh
  chmod +x uninstall.sh

④开始安装

  sh install.sh docker-18.06.3-ce.tgz

⑤一键卸载脚本

touch uninstall.sh
vim uninstall.sh    

#!/bin/sh
 
echo '停止docker'
systemctl stop docker
echo '删除docker.service'
rm -f /etc/systemd/system/docker.service
echo '删除docker文件'
rm -rf /usr/bin/docker*
echo '重新加载配置文件'
systemctl daemon-reload
echo '卸载成功'

2.Docker常用命令

帮助文档：docs.docker.com/engine/refe…

<1>镜像命令

<2>容器命令

<3>日志，元数据，进程查看

<4>进入容器与拷贝（拷贝是手动的过程，-v 卷挂载实现自动同步）命令

3.Docker练习

<1>部署Nginx

    I.搜索镜像 search（先去docker hub搜索，有更全的信息）
    II.下载镜像 pull
    III.本地运行测试       

    IV.端口暴露概念        

<2>部署Tomcat

七.Docker镜像底层原理

1.底层的系统结构

Client-Server结构，Docker这个的守护进程运行在主机（宿主）上。通过Socket从客户端访问。DockerServer接收到Docker-Client的指令，就会执行这个命令        

2.Docker比vm快的原因

3.制作自己的一个镜像

参考上面Docker对于镜像的说明

八.容器数据卷（volume）（卷技术）（容器的挂载）

1.是什么

docker的理念是把应用和环境打包成一个镜像，然后run就是容器了，而数据都在容器中，如果容器删除，数据机会丢失；但是我们的需求是数据可以持久化；比如说下载了一个mysql镜像，执行run转为容器，一旦删除这个容器数据也会丢失，相当于删库跑路，我们的需求是把Mysql的数据存在本地或其他地方而不是存在容器
所以要有一个容器之间数据共享的技术：让Docker容器中产生的数据同步到本地，这样删除容器数据就不会丢失。这就是卷技术（也叫目录的挂载，就是将容器内的目录，挂载到Linux或虚拟机上）

挂载：        

2.为什么要用

思考：上面用docker部署一个最简单的Tomcat，会发现确实东西，如果要放进去项目，需要进入容器手动把项目放到webapps下；我们要实现的是，在容器外部提供一个映射路径webapps，当我们在外部的映射路径下放置项目时，会自动同步到容器内。
举例：我们上面部署的容器是tomcat+网页，如果删了docker，东西都没了；获取另外一个容器里有tomcat+mysql，删了docker，数据都没了，肯定是不行的，所以要解决这个问题
解决容器的持久化和同步操作，使用容器卷技术后，修改只需要在本地修改，容器内会自动同步
总结就是实现容器的数据持久化功能

3.使用数据卷（怎么用）

<1>方式一：直接通过命令挂载

I.使用命令挂载

docker run -it -v 主机目录：容器目录

II.测试容器内数据和本机数据是否同步

同步的过程可以理解为双向绑定

III.测试删除容器后，本机数据是否可以保留

IV.测试Mysql同步数据

i.连接数据库，同步数据

ii.删掉容器，查看本地数据是否可以保留

发现，就算我们把容器删除，挂载到本地的数据卷依旧没有丢失，实现了数据持久化功能

V.具名挂载和匿名挂载

i.使用

ii.区分具名挂载和匿名挂载和指定路径的挂载方式

iii.扩展

<2>方式二：初始DockerFile-实现卷挂载的另一种方式

DockerFile就是用来构建docker镜像的构建文件

I.创建dockerfile文件，编写脚本用来生成镜像

挂载的时候，前面通过-v，还有具名挂载，匿名挂载方式，还可以在构建镜像的同时挂载     

II.启动自己写的容器

III.容器内部创建一个文件，并查看卷挂载的路径

IV.测试文件是否同步出去了

<3>.卷挂载技术总结

如果构建镜像的时候没有挂载卷，就需要手动挂载（-v 卷名：容器内路径）

4.数据卷容器（把容器变为数据卷容器）

多个容器之间通过数据卷挂载实现数据共享，如多个mysql之间的数据同步；
--volumes from

<1>启动多个容器

I.启动第一个容器

II.启动第二个容器

<2>数据同步

在父容器创建一个文件，查看另外一个容器是否同步  
I.在第一个容器的挂载文件中新建文件   

II.查看第二个容器是否生成文件完成同步

<3>测试同步

删除父容器，不影响另外的容器，还可以访问文件——>备份的机制，不是共享的机制（共享的化，删除其中一个，别的也访问不到） 

I.共享

II.数据卷容器

<4>.多个mysql实现数据共享

5.结论

容器之间配置信息的传递：比如做集群的时候经常要把集群的文件拷贝到多个配置文件里，每一个服务器上都要有
数据卷容器的生命周期一直持续到没有人使用为止，但是一旦使用-v持久化到了本地，本地的数据是不会被删除的
****通过容器数据卷，就可以做到数据持久化，并用挂载的方式把重要的文件挂载到文件系统内，这样删除容器，容器的数据就不会消失，可以在本地找到

九.DockerFile(命令参数脚本)（制作一个镜像）

1.是什么

<1>DockerFile就是用来构建docker镜像的构建文件
<2>构建过程

2.为什么用

1.docker file是面向开发的，我们要发布项目，做镜像，就需要编写dockerfile 文件
2.在公司中做容器部署的时候，docker是一个交付的标准，之前是需要叫一个jar包或者war包，现在就是交一个docker镜像，因此要使用docker file把代码和服务构建成镜像；
之前发布的是jar或war包，现在就算是jar包，也要变成Docker镜像，当启动镜像的时候，里面的jar包全部自动运行
3.Docker三部曲
Docker File:构建文件，定义了一切的步骤，好比是源代码
DockerImages:通过Docker File构建生成的镜像，这就是最终发布和运行的产品 
Docker容器 ：是镜像运行起来提供服务的

3.怎么用

<1>构建步骤

i.编写一个dockerfile文件
ii.docker build构建成为一个镜像
iii.docker run 运行镜像
iv.docker push发布镜像：可以发布到两个地方（相当于开源）
    Docker Hub
    阿里云镜像仓库

<2>Docker File的指令

<3>实例：构建自己的centos

I.创建一个目录

[root@userAlex /]# cd home
[root@userAlex home]# ls
alex  www
[root@userAlex home]# mkdir dockertest
[root@userAlex home]# ls
alex  dockertest  www

II.创建一个自己的docker file，并构建一个自己的centos

i.编写Docker File 文件

[root@userAlex dockertest]# vim mydockerfile-centos
[root@userAlex dockertest]# cat mydockerfile-centos
FROM centos
MAINTAINER alex<1021355326@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

ii.通过编写的这个文件构建镜像

docker build -f mydockerfile-centos -t mycentos:0.1 .
#-f :指的是构建镜像用的是哪个dockerfile文件
#-t :生成的目标镜像名字，可以加版本号

iii.测试运行

<4>CMD和ENTRYPOINT区别

I.cmd测试

使用cmd，启动容器时执行查看当前目录的命令

II.ENTRYPOINT

<5>实例：DockerFile制作Tomcat镜像

I.准备镜像文件：tomcat压缩包，jdk压缩包

[root@userAlex /]# cd home/alex
[root@userAlex alex]# ls
apache-tomcat-8.5.73  apache-tomcat-8.5.73.tar.gz  jdk-8u65-linux-x64.rpm

II.写阅读文档和Dockerfile文件（docker默认会找Dockerfile名字，写这个名字就不需要-f指定）

[root@userAlex alex]# touch read.txt
[root@userAlex alex]# vim Dockerfile
[root@userAlex alex]# cat Dockerfile
FROM centos
MAINTAINER alex<1021355326@qq.com>

COPY read.txt /usr/local/read.txt

ADD jdk-8u144-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.73.tar.gz /usr/local/

RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_65
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.73
ENV CATALINA_BASE /usr/local/apache-tomcat-8.5.73
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME /bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-8.5.73/bin/startup.sh && tail -F /url/local/apache-tomcat-8.5.73/bin/logs/catalina.out

III.构建镜像

[root@userAlex alex]# docker build -f Dockerfile -t diytomcat .
Successfully built 99d4e823eb47
Successfully tagged diytomcat:latest

IV.查看镜像

[root@userAlex java]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
diytomcat    latest    99d4e823eb47   2 minutes ago   689MB
mycentos     0.1       8f1c61bb3364   4 hours ago     326MB
centos       latest    5d0da3dc9764   3 months ago    231MB
[root@userAlex java]# 

V.启动

[root@userAlex /]# docker run -d -p 9090:8080 --name alextomcat -v /home/alex/test:/url/local/apache-tomcat-8.5.73/webapps/test -v /home/alex/tomcatlogs/:/url/local/apache-tomcat-8.5.73/logs diytomcat
#以后台方式运行容器；
#暴露端口对外9090，对内8080；
#给容器起名字alextomcat
#把容器内tomcat发布项目的目录挂载出来到宿主机的test目录（把容器内的test和外部的test绑定），以后发布tomcat的项目放到本地的test下，就会同步到容器内的对应文件
#把容器内的日志文件也挂载出来

VI.测试访问

[root@userAlex alex]# curl localhost:9090

VII.发布一个项目

因为做了卷挂载，直接在本地编写项目发布就可以    

十.发布自己的镜像

镜像可以发布到Dockler Hub或者阿里云镜像服务

1.发布到DockerHub

<1>从服务器登录DockerHub

[root@userAlex /]# docker login -u alex1021355326
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
[root@userAlex /]#

<2>提交镜像push

[root@userAlex /]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
tomcat       latest    fb5657adc892   2 months ago   680MB
[root@userAlex /]# docker tag fb5657adc892 alex/tomcat:1.0
[root@userAlex /]# docker push alex/tomcat:1.0

2.发布到阿里云镜像服务

<1>登录阿里云

<2>找到容器镜像服务

<3>创建命名空间

存镜像的地方    

<4>创建镜像仓库

<5>从服务器登录阿里云

<6>提交镜像push

十一.Docker网络

需求：容器之间不使用ip或地址，怎么能直接用服务名字ping通

  实现高可用
--link：    

十二.springboot微服务打包成docker镜像

1.构建springboot项目

2.打包项目

3.编写dockerfile

4.构建镜像

5.发布运行

[root@userAlex home]# mkdir idea
[root@userAlex home]# ls
alex  dockertest  idea  www
[root@userAlex home]# cd idea
[root@userAlex idea]# ls
Dockerfile  test-0.0.1-SNAPSHOT.jar
[root@userAlex idea]# docker build -t alex666 .
Sending build context to Docker daemon  17.56MB
Step 1/5 : FROM java:8
[root@userAlex idea]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
alex666      latest    222f13d6ccf0   18 seconds ago   661MB
[root@userAlex idea]# docker run -d -P --name alex-springboot-web alex666
89af8dd17b8b3c253ae22c208512f2d239f4f193a6a2138cce6dd78d504a0a6e
[root@userAlex idea]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                     NAMES
89af8dd17b8b   alex666   "java -jar /app.jar …"   20 seconds ago   Up 19 seconds   0.0.0.0:49156->8080/tcp   alex-sp
root@userAlex idea]# curl localhost:49156
{"timestamp":"2022-03-13T14:40:42.750+00:00","status":404,"error":"Not Found","path":"/"}[root@userAlex idea]# 
[root@userAlex idea]# curl localhost:49156/hello
hello,docker[root@userAlex idea]#