Docker,Docker-compose,Rancher k8s容器使用入门

Docker,Docker-compose,Rancher k8s容器使用入门

1. Docker是什么？

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker ，就不用担心环境问题。

2. Docker的优势

• docker 启动快速属于秒级别；
• docker 需要的资源更少；
• docker 更轻量；
• 快速创建、删除。

3. Docker基础知识

• Image(镜像)
• Container(容器)
• Repository(仓库)

1. 镜像
   镜像是 Docker 运行容器的前提，仓库是存放镜像的场所，镜像是docker的核心；
   Docker 镜像可以看作是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像不包含任何动态数据，其内容在构建之后也不会被改变。镜像可以理解为一个应用程序的运行环境，包含应用程序所需的运行库，配置文件及依赖，当我们运行容器时就是在一个隔离的环境中运行起了我们的应用程序。各个容器运行时有各自的独立环境，相互之间不受影响。

2. 容器
   容器是在镜像的基础上运行的一层可读写层，容器 = 镜像 + 读写层，有了读写层才能与宿主机的文件系统进行IO操作，实现宿主机及容器之间的相互访问。

3. Docker 仓库是集中存放镜像文件的场所。镜像构建完成后，可以很容易的在当前宿主上运行，但是， 如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry (仓库注册服务器)就是这样的服务。
   docker仓库分为两种形式：public(公有仓库)，private(私有仓库)。
   public公有镜像仓库类似GitHub代码托管服务，全球的docker使用者都可以免费上传、下载自己制作的镜像，并可以对镜像进行交易，我们在制作镜像时，一般都是基于共有基础镜像仓库制作；
   private私有镜像是使用开源软件搭建的私有镜像仓库，类似Gitlab，这样自己制作的镜像不会暴露于公网，造成安全隐患。

参考地址：https://blog.csdn.net/deng624796905/article/details/86493330

4. Docker使用

• 安装：

windows安装参考:

https://www.runoob.com/docker/windows-docker-install.html

mac安装参考：

https://hub.docker.com/editions/community/docker-ce-desktop-mac

Linux（centos7）安装，需要Linux内核3.0以上版本：

确保宿主机能够联网：
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum clean all 
yum makecache fast
yum -y install docker-ce
systemctl start docker && systemctl enable docker

• 使用：

配置官方镜像加速：

vim /etc/docker/daemon.json
输入以下配置：
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}
然后重启docker:
systemctl restart docker
查看配置是否生效：
docker info
在输出中有：
Registry Mirrors:
 https://registry.docker-cn.com/

制作镜像：对于Java应用，要想运行为容器，首先要制作成镜像。一般docker用户都是基于基础镜像制作自己的镜像的，这里以Java为例。
在https://hub.docker.com/上搜索Java，一般star数高的镜像是官方镜像，当然上面也会注明是否官方镜像。

进入详情页，详情页中都会有描述如何使用的信息，我们进入TAG标签页，找到8-jre，一个比较小的镜像。

将镜像拖到本地：

docker pull java:8-jre

查看是否下载成功：

docker image  ls

如果需要其他镜像版本，拉取时只需要用项目名称+镜像标签即可。

Dockerfile编写：

cd ~
创建一个空文件夹并进入该文件夹
mkdir docker && cd docker
创建Dockerfile文件，touch Dockerfile,输入以下内容：
FROM java:8-jre     # 使用的基础镜像名称，本地不存在会自动拉取
MAINTAINER xxx <xxx@xxx.com>	# 维护者的名称及邮箱地址
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone   # 将本地操作系统的时区设置拷进docker容器
ADD witc-eurake-server.jar /app/      # 将当前文件夹下的witc-eurake-server.jar添加到容器
CMD ["java","-Xms512m","-Xmx512m","-Deureka.client.serviceUrl.defaultZone=http://192.168.56.19:8080/eureka/eureka/,http://192.168.56.20:8080/eureka/eureka/","-Dspring.profiles.active=docker","-Dspring.cloud.config.profile=docker","-jar","/app/witc-eurake-server.jar"]  # Java程序的启动命令
EXPOSE 8080   # Java程序暴露的端口

这里需要注意：
Dockerfile名称固定，不能改成其他名称，需要做成镜像的jar建议与Dockerfile放着同一目录，并且除了这两个文件以为没有其他文件。docker容器里面的时间默认是标准的UTC时间，跟北京时间相差了8个小时，因此为了保持容器与宿主机时间一致，需要将时间设置拷进容器，前提是宿主机的时间必须要正确，Linux系统可以使用ntpdate做时间同步。CMD指令写的是Java程序启动的命令，根据需要修改即可，在这个容器启动时候会自动执行，这种写法在容器启动的时候会以优先级最高的形式运行。EXPOSE填写的是Java程序需要暴露的端口，根据需要修改，与应用保持一致。
构建镜像：在Dockerfile所在的目录执行

docker build -t witc-eureka-server.jar .

-t 指定镜像的名称，可以加个标签如：witc-eureka-server:v1.0 表示witc-eureka-server的第一个版本，默认为latest，即最新版本。


运行：

docker run --name witc-eurake-server witc-eureka-server:latest

但是这样跑起来只能在宿主机本地访问。
Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。

使用ifconfig查看

进入容器查看容器的IP：

docker exec -it witc-eurake-server /bin/bash  # 以交互模式进入容器
ps -ef|grep java	# 查看容器里面的的Java进程
ip a	# 查看容器的网络信息
ss -tnlup|grep java	# 查看容器里面Java程序监听的端口
cd /bin/  && ls	# 查看容器里面支持的命令
ping 192.168.56.20	 # 查看容器里面与宿主机是否相通
ping 172.17.0.2 	# 查看宿主机与容器是否互通

此时可以在宿主机上通过wget，curl命令查看Java程序是否运行成功。
要想让宿主机以外的其他机器能够访问容器里面的应用，需要绑定一个宿主机的端口与容器端口做映射，因此启动命令如下：

docker run --name witc-eurake-server -p 8080:8080 witc-eurake-server:latest  # 映射宿主机所有网卡的8080端口，前面是宿主机的端口

其他应用也可以做成docker容器，只需将Dockerfile修改即可，以配置中心为例，可以看到已经注册上eurake了。

这样启动的容器运行在前台，而且经过了宿主机的转发，性能有一定的损耗，因此可以直接使用宿主机的网络名称空间，但要保证端口不冲突。后台启动的容器默认会将启动时的标准输出及标准错误输入到/var/lib/docker/containers/<容器id>/<容器id>-json.log文件中，随着Java程序的运行，日志会越来越大，因此需要做日志大小限制。

vim /etc/docker/daemon.json
{
    "registry-mirrors": ["https://registry.docker-cn.com"],
    "log-driver":"json-file",
    "log-opts": {"max-size":"200m", "max-file":"3"}
}

默认写入到/workspace/log的日志在宿主机上不好找，因此也需要挂载到宿主机的一个目录上。最终的启动命令如下：

docker run --rm -d --network host -v /workspace/log:/workspace/log -m 1g --cpus=1 --name witc-eurake-server witc-eurake-server:latest
--rm     表示容器退出后随之将其删除，包括输出的日志也会删除；
  -d 	 表示容器以后台方式运行
--network host 表示使用宿主机的网络名称空间
  -v     表示挂载容器的/workspace/log地址，通过访问宿主机的/workspace/log地址相当与容器的/workspace/log地址，前面是宿主机的地址；
  -m     表示容器最多能够使用1g内存
--cpus   表示容器最多只能1核CPU
--name   表示给启动的容器取一个名称

到这里为止就可以部署一套基于docker容器的Java集群了。

docker导入导出：

docker save -o java.gz witc-eurake-server:latest witc-config-server:latest
save -o 指定导出镜像到当前目录，导出的文件的名称为java.gz，后面跟上需要导出的镜像名称，多个镜像以空格隔开。
导出后可使用scp命令拷贝到其他安装了docker的机器，然后使用：
docker load < java.gz
即可将导出的镜像导入到另一条机器当中。

docker私有镜像仓库的使用：
开源的私有镜像仓库一般使用的是VMware公司出品的harbor。下载地址：https://storage.googleapis.com/harbor-releases/release-1.8.0/harbor-offline-installer-v1.8.1.tgz
一般下载离线包即可。

解压后目录如下：

修改配置文件如下：

hostname: 192.168.1.191	# 访问的的域名，这里写宿主机IP即可
http:
  port: 80	# 访问端口
harbor_admin_password: xxxx# 登陆密码
database:
  password: 123456
data_volume: /data		# 挂载宿主机的目录
clair: 
  updaters_interval: 12
  http_proxy:
  https_proxy:
  no_proxy: 127.0.0.1,localhost,core,registry
jobservice:
  max_job_workers: 10
chart:
  absolute_url: disabled
log:
  level: info
  rotate_count: 50
  rotate_size: 200M
  location: /var/log/harbor
_version: 1.8.0

配置好后还不能启动，还需要下载docker-compose二进制文件，下载方式：

curl -L https://github.com/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

然后在harbor解压目录运行

sudo ./install.sh

启动完成后即可通过浏览器管理harbor镜像仓库

登录后创建一个仓库名称，进入仓库即可看到镜像推送的命令。


docker默认推送镜像的仓库是docker hub要使用第三方镜像仓库还需要修改配置文件，再重启docker：

vim /etc/docker/daemon.json
{
    "registry-mirrors": ["https://registry.docker-cn.com"],
    "insecure-registries":["192.168.1.191"],      # 添加此配置
    "log-driver":"json-file",
    "log-opts": {"max-size":"200m", "max-file":"3"}
}

使用

docker login http://192.168.1.191     # 输入用户名密码登录自建私有镜像仓库

登录后即可从私有仓库推送，拉取镜像了。
harbor镜像仓库管理：
harbor解压后的文件建议不要删除，方便通过docker-compose管理，在harbor解压目录执行：

查看harbor是否启动成功：
docker-compose ps
停止harbor：
docker-compose down
启动harbor：
docker-compose up

更多命令请查看官方文档：

https://github.com/docker/compose/releases/

批量管理docker容器集群
有时候需要管理一群docker容器，可使用docker-compose进行管理。要编排一组容器，首先需要编写docker-compose.yml此名称不能改变，就像Dockerfile文件一样，示例如下：

version: '2.1'	# 这个一定要写，这里写2.1即可
services:       # 定义服务
  eureka-server:    # 服务的名称
    image: witc-eurake-server:latest  # 使用的镜像
    restart: always		# always表示容器启动失败会自动重启
    ports:
      - 8080:8080	# 暴露的端口，前面是宿主机的端口

  config-server:
    image: witc-config-server:latest
    restart: always
    links:
      - eureka-server:8080    # config-server需要注册到eureka-server，所以这里写上名称+端口
    ports:
      - :7001	# 不需要从宿主机访问可以不写端口

  api-gateway:
    image: witc-api-gateway:latest
    restart: always
    links:
      - eureka-server:8761
    ports:
      - :8888
  
  tenants-web:
    image: witc-tenants-web:latest
    restart: always
    links:
      - eureka-server:8761
    ports:
      - 9006:9006  

随后可通过docker-compose进行管理了

docker-compose up   # 启动
docker-compose up -d # 后台启动
docker-compose down # 停止
docker-compose ps 	# 查看

• docker集群
  前面介绍的docker使用方法都是在单个宿主机上完成的，世纪使用过程中是以集群的形式使用的。docker自身提供了轻量级的docker swarm,通过它可以对docker容器进行管理及编排，实现自动扩缩容，自动重启，故障转移等，是docker容器编排的基础。

初始化docker swarm集群：以3个节点为例
首先要保证这三个节点时间要一致，可通过date命令查看，通过ntpdate命令同步时间，安装好docker。
安装好后再一台宿主机上执行：

docker swarm init --advertise-addr 192.168.1.100  # 指定使用某个IP

输出如下：不同的机器输出的token不同

Swarm initialized: current node (5n1l6261akogeuxysrgn2ipxz) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-2bgkinnbc0rmlj6kpotyrlj0uz51l2ikinttsk960dxro558x4-6zajfnahtv9ye39momddh5kru 192.168.1.100:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

通过提示，我们复制docker swarm join --token SWMTKN-1-2bgkinnbc0rmlj6kpotyrlj0uz51l2ikinttsk960dxro558x4-6zajfnahtv9ye39momddh5kru 192.168.1.100:2377指令，然后其他两台机器上执行即可创建3台docker swarm集群了。
查看集群状态：

[root@docker ~]# docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS
k89s71elf81vbn7pytwszmgr5     192.168.1.100          Ready               Active
5n1l6261akogeuxysrgn2ipxz *   192.168.1.101          Ready               Active              Leader
ye5x8hci1chmo8nyjx8y4thhy     192.168.1.102          Ready               Active

docker swarm服务的编排与docker compose类似，可以参考：

https://yeasy.gitbooks.io/docker_practice/content/swarm/

k8s集群搭建：
Kubernetes(k8s)是Google出品的目前最流行的容器编排系统，不仅可以编排docker容器，还一样编排Rocket容器技术，功能非常强大。官网https://kubernetes.io/
由于k8s集群的搭建需要翻墙下载镜像，因此在测试环境中使用较为简便的Rancher平台即可。
Rancher是第三方公司开源的企业级k8s容器编排系统，其集群搭建简单，拥有Web端操作界面，可以很方便的通过鼠标对k8s进行管理。官方网站：https://www2.cnrancher.com/

安装Rancher管理节点：
Rancher管理节点也需要docker环境，因此需要提前安装好docker引擎，并做好时间同步，执行以下命令即可初始化：

sudo docker run -d --restart=unless-stopped -p 8080:8080 rancher/server:stable

等待安装完以后，就可以通过浏览器输入宿主机IP+80端口进行访问管理，第一次打开需要设置密码，按照提示来就行，语言选择简体中文。

创建k8s集群：
登录Rancher以后，默认是没有任何集群的，点击右上角添加集群。


点击下一步：

部署主节点时，需要将etcd,control,worker都勾选上，然后点击复制，在安装好docker并且做了时间同步的机器上执行复制的命令即可，集群中需要三台主节点，因此三台主机都执行相同命令，这样三个主节点就准备好了。
部署woker节点时，把etcd,control选项勾选掉，执行复制的命令加入集群即可。

部署服务：

进入部署界面：填写服务名称，所使用的镜像及命名空间，这里部署一个应用

下拉进入数据卷：添加卷 —> 选择映射主机目录，将容器的日志目录映射出来，方便查看。

点击显示高级设置 --> 找到安全/主机设置下面的内存预留限制容器使用的CPU，内存，然后点击启动即可

添加代理：
因为部署的时候没有映射端口，如果需要外网访问，可以添加Ingress代理过去。

一般测试环境使用自动生成.xip.io后缀域名即可。
添加完成以后就可在浏览器上访问了。

日志查看：


即可查看应用运行时的输出日志。
查看记录到/workspace/log的日志：

更新镜像时只需要点击升级，然后修改docker镜像版本重新部署即可。

---

END