云原生学习

学习k8s的实验资料


dockerfile

相关官网地址

Docker官网：https://docs.docker.com/ Docker的github地址：https://github.com/moby/moby Dockerhub官网:https://registry.hub.docker.com  如果docker官方registry拉取镜像速度很慢，可以尝试daocloud提供的加速器服务 https://dashboard.daocloud.io/mirror

dockerfile 语法讲解

dockerfile是一个用于定于Docker镜像的文本文件。包含了一系列指令和参数，用于指示docker在构建镜像时应该执行哪些操作，例如基于哪个基础镜像、复制哪些文件到镜像中、运行哪些命令的等等。通过dockerfile,开发人员可以将应用程序和其因爱项打包在一起，创建出一个可移植的docker镜像，使得这个应用程序可以在任何docker环境中都能快速部署和运行。

FROM centos    #基础镜像，这里的 centos 就是定制需要的基础镜像，后续的操作都是基于centos镜像。。
MAINTAINER xianchao  #指定镜像的作者信息
RUN rm -rf /etc/yum.repos.d/*  #指定在当前镜像构建过程中要运行的命令，有两种模式，shell和exec，后续会介绍
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/  #复制指令，从上下文目录中复制文件/目录到容器指定路径
RUN yum install wget -y
RUN yum install nginx -y
COPY index.html /usr/share/nginx/html/
EXPOSE 80  #声明端口
ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"]  #指定在启动的容器中指定默认要运行的程序

创建index.html vim index.html

<html>
<head>
        <title>page added to dockerfile</title>
</head>
<body>
        <h1>i am in df_test </h1>
</body>
</html>

语法详解

  • FROM：基础镜像，必须是可以下载下来的，定制的镜像都是基于 FROM 的镜像。
  • MAINTAINER：指定镜像的作者信息
  • RUN：指定在当前镜像构建过程中要运行的命令 语法包含两种模式：
    1. Shell模式: RUN <command> (这个是最常用的，需要记住)
    2. exec模式： RUN ["executable","param1","param2"] 例如：RUN ["/bin/bash","-c","echo hello"] 等价于 /bin/bash -c echo hello RUN yum install wget -y 换成 exec 模式就是 RUN["/bin/bash","-c","yum install wget -y"]
  • EXPOSE：声明端口 作用：
    1. 帮助镜像使用者理解这个镜像服务的守护端口，方便配置映射。
    2. 在使用随机端口映射时，即 docker run -P 时，会自动随机映射 EXPOSE 端口
    3. 可以是一个或者多个端口，也可以指定多个 EXPOSE 格式：EXPOSE 80 8080
  • CMD：为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束。CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖。 类似 RUN 指令，用于运行程序，但二者运行的时间点不同：CMD 在 docker run 时运行，RUN 是在 docker build 构建镜像时运行。 语法也包两种模式：
    1. shell模式：CMD <command>
    2. exec模式: CMD ["executable","param1"，"param2"]
    3. 作为ENTRYPOINT指令的默认参数：CMD ["param1","param2"] 案例： 
      mkdir -p /root/dockerfile/
vi test
#first dockerfile
FROM centos
RUN rm -rf /etc/yum.repos.d/*
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/
MAINTAINER karen
RUN  yum  install  nginx -y
EXPOSE 80 81
CMD ["/usr/sbin/nginx","-g","daemon off;"]
#构建镜像：
[root@node3 dockerfile]# wget  https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
[root@xianchaomaster1 dockerfile]# docker build -t="xianchao/test-cmd:v1" -f ./test .   #-f:指定dockerfile文件
#基于上面构建的镜像运行一个容器，此时不需要跟 nginx -g daemon off；
[root@node3 test]# docker run -P --name cmd_test2 -d xianchao/test-cmd:v1  
#-P：给创建的容器随机映射空闲端口 
#-d:让容器在后台运行

  • ENTERYPOINT：类似于 CMD 指令，但其不会被 docker run 的命令行参数指定的指令所覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。但是, 如果运行 docker run 时使用了 --entrypoint 选项，将覆盖 entrypoint指令指定的程序。 优点：在执行 docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。 注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。 语法：
    1. shell模式：ENTERYPOINT <command>
    2. exec模式:ENTERYPOINT ["executable","param1","param2"] 可以搭配 CMD 命令使用：一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。 示例： 假设已通过 Dockerfile 构建了 nginx:test 镜像： 
      [root@xianchaomaster1 ~]# mkdir nginx
[root@xianchaomaster1 ~]# cd nginx/
[root@xianchaomaster1 nginx]# vim dockerfile
FROM nginx
ENTRYPOINT ["nginx", "-c"] # 定参  nginx是nginx命令行工具,-c指定基于哪个文件运行nginx
CMD ["/etc/nginx/nginx.conf"] # 变参 
[root@xianchaomaster1 nginx]# docker build -t nginx:test . -f /root/nginx/dockerfile
#不传参运行
$ docker run  nginx:test  #容器内会默认运行 nginx -c /etc/nginx/nginx.conf 命令，启动主进程。
#传参运行
mkdir /etc/nginx -p
touch /etc/nginx/new.conf
docker run --name nginx  nginx:test /etc/nginx/new.conf
#容器内会默认运行命令 nginx -c /etc/nginx/new.conf，启动主进程(/etc/nginx/new.conf:假设容器内已有此文件)

  • COPY：复制，从上下文目录中复制文件或者目录到容器里指定路径。 语法： COPY [--chown=<user>:<group>] <源路径1>...  <目标路径> COPY [--chown=<user>:<group>] ["<源路径1>",...  "<目标路径>"] [--chown=<user>:<group>]：可选参数，用户改变复制到容器内文件的拥有者和属组。 <源路径>：源文件或者源目录，这里可以是通配符表达式，其通配符规则要满足 Go 的 filepath.Match 规则。 例如： COPY hom* /mydir/ COPY hom?.txt /mydir/ <目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。

  • ADD:ADD 指令和 COPY 的使用格式一致（同样需求下，官方推荐使用 COPY）。功能也类似，不同之处如下： ADD 的优点：在执行 <源文件> 为 tar 压缩文件时，压缩格式为 gzip, bzip2 以及 xz 的情况下，会自动复制并解压到 <目标路径>。 ADD 的缺点：在不解压的前提下，无法复制 tar 压缩文件，会令镜像构建缓存失效，从而可能会令镜像构建变得比较缓慢。具体是否使用，可以根据是否需要自动解压来决定。 ADD vs COPY：ADD包含类似tar的解压功能，如果单纯复制文件，dockerfile推荐使用COPY。

  • VOLUME：定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷。 作用：
    1. 避免重要的数据，因容器重启而丢失，这是非常致命的。
    2. 避免容器不断变大。 语法： VOLUME ["<路径1>", "<路径2>"...] VOLUME <路径> 在启动容器 docker run 的时候，我们可以通过 -v 参数修改挂载点。 示例： 
      [root@xianchaomaster1 ~]# mkdir vvolume
[root@xianchaomaster1 ~]# cd vvolume/
[root@xianchaomaster1 vvolume]# cat dockerfile
#first dockerfile
FROM centos
MAINTAINER karen
RUN rm -rf /etc/yum.repos.d
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install nginx -y
EXPOSE 80
VOLUME ["/data"]
CMD ["/usr/sbin/nginx","-g","daemon off;"]
[root@xianchaomaster1 vvolume]# docker build -t="volume:v1"  -f ./dockerfile .
[root@xianchaomaster1 vvolume]# docker run --name volume1 -d -P volume:v1

      此时在主机对应的路径下创建文件，在容器的/data目录下也能看到，反之亦然。 注意：删除容器后，主机对应卷中的数据依然存在。

也可以用在启动容器的时候用-v 主机路径:容器挂载点 来指定容器的挂载卷 示例：docker run --name volume2 -v /eisoo:/data -d -P volume:v1 表示容器中/data目录下的数据都挂载在主机的/eisoo目录下

  • WORKDIR:指定工作目录。 用 WORKDIR 指定的工作目录，会在进入容器时自动进入到指定目录。（WORKDIR 指定的工作目录，必须是提前创建好的）。 docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才会一直存在。 语法：WORKDIR <工作目录路径> #路径要填绝对路径 示例：WORKDIR /path/to/workdir

  • ENV：设置环境变量 语法： ENV <key> <value> ENV <key>=<value>... 以下示例设置 NODE_VERSION =6.6.6， 在后续的指令中可以通过 $NODE_VERSION 引用：
ENV NODE_VERSION 6.6.6
RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \ && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"

  • USER:指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已经存在）。 语法：USER <用户名>[:<用户组>]

  • ONBUILD：延迟构建命令的执行  Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这时执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。 语法：ONBUILD <其它指令> 作用：为镜像添加触发器,当一个镜像被其他镜像作为基础镜像时需要写上OBNBUILD,会在构建时插入触发器指令。 示例： 
    [root@karen ~]# mkdir onbuild
[root@karen ~]# cd onbuild/
[root@karen ~]# cat index.html
<html>
<head>
<title>page added to dockerfile</title>
</head>
<body>
<h1>i am in df_test </h1>
</body>
</html>
[root@karen ~]# vim onbuild.config
FROM centos
MAINTAINER karen
RUN rm -rf  /etc/yum.repos.d
COPY  Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install nginx -y
ONBUILD COPY index.html /usr/share/nginx/html/
EXPOSE 80
ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"]
[root@karen ~]# docker build -t="onbuild-nginx:v1" -f ./onbuild.config .
[root@karen ~]# docker run -d --name onbuild1 -p 80 onbuild-nginx:v1
#根据已经构建的镜像onbuild-nginx:v1创建新的镜像onbuild-nginx:v2
[root@karen ~]# cp onbuild.config onbuild2.config
[root@karen ~]# vi onbuild2.config
[root@karen ~]# cat onbuild2.config
FROM onbuild-nginx:v1
MAINTAINER karen
RUN rm -rf  /etc/yum.repos.d
COPY  Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install nginx -y
ONBUILD COPY index.html /usr/share/nginx/html/
EXPOSE 80
ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"]
[root@karen ~]# docker build -t="onbuild-nginx:v2" -f ./onbuild2.config .
[root@karen ~]# docker run -d --name onbuild2 -p 80 onbuild-nginx:v2

    容器onbuild1访问nginx 根据镜像onbuild-nginx:v1创建出来的镜像onbuild-nginx:v1启动的容器onbuild2,访问nginx，显示的就是我们自己写的index.html

dockerfile如何构建企业级镜像？

dockerfile构建nginx镜像

[root@karen ~]# vim dockerfile
FROM centos
MAINTAINER karen
RUN rm -rf /etc/yum.repos.d/*
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install wget -y
RUN yum install nginx -y
COPY index.html /usr/share/nginx/html/
EXPOSE 80
ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"]  #表示容器运行时，自动启动容器里的nginx服务

[root@karen ~]# vim index.html

<html>
<head>
        <title>page added to dockerfile</title>
</head>
<body>
        <h1>Hello ,My Name is Karen </h1>
</body>
</html>

构建镜像：docker build -t="karen/nginx:v1" -f ./dockerfile . 查看镜像是否构建成功：docker images | grep nginx 显示如下说明镜像部署成功： 基于刚才的镜像启动容器：docker run -d  -p 80 --name html2 karen/nginx:v1 查看容器信息:docker ps | grep html 查看容器里部署的nginx网站的内容：

dockerfile构建tomcat镜像

把apache-tomcat-8.0.26.tar.gz 和jdk-8u45-linux-x64.rpm和Centos-vault-8.5.2111.repo上传到dockerfile所在目录

[root@karen ~]# mkdir tomcat8
[root@karen tomcat8]# cd tomcat8
[root@karen tomcat8]# cat  dockerfile
FROM centos
MAINTAINER karen
RUN rm -rf /etc/yum.repos.d/*
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install wget -y
ADD jdk-8u45-linux-x64.rpm /usr/local/
ADD apache-tomcat-8.0.26.tar.gz /usr/local/
RUN cd /usr/local && rpm -ivh jdk-8u45-linux-x64.rpm
RUN mv /usr/local/apache-tomcat-8.0.26 /usr/local/tomcat8
EXPOSE 8080 
#开始构建镜像
[root@karen tomcat8]# docker build -t="tomcat8:v1" -f ./dockerfile .
#运行一个容器
[root@karen tomcat8]# docker run --name tomcat8  -itd -p 8080 tomcat8:v1

此时查看tomcat8映射的端口是32778 访问tomcat提示无法访问，原因是tomcat服务没有启动 

#进入到容器
[root@karen tomcat8]#  docker exec -it tomcat8  /bin/bash
#启动tomcat
[root@5b174e6923ec /]# /usr/local/tomcat8/bin/startup.sh
#查看进程，看看是否启动成功
[root@5b174e6923ec /]# ps -ef | grep tomcat

此时就可以访问到tomcat

上述方法需要进到容器中，手动启动tomcat服务，那如果想要启动容器，tomcat也自动启动，则需要按照如下方法构建镜像：

[root@karen tomcat8]# vim dockerfile1
FROM centos
MAINTAINER karen
RUN rm -rf /etc/yum.repos.d/*
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/
RUN yum install wget -y
ADD jdk-8u45-linux-x64.rpm /usr/local/
ADD apache-tomcat-8.0.26.tar.gz /usr/local/
RUN cd /usr/local && rpm -ivh jdk-8u45-linux-x64.rpm
RUN mv /usr/local/apache-tomcat-8.0.26 /usr/local/tomcat8
ENTRYPOINT /usr/local/tomcat8/bin/startup.sh && tail -F /usr/local/tomcat8/logs/catalina.out
EXPOSE 8080 
[root@karen tomcat8]# docker build -f dockerfile1 -t="tomcat8:v2" .
[root@karen tomcat8]# docker run --name tomcat8-1  -itd -p 8080 tomcat8:v2 /bin/bash
[root@karen tomcat8]# docker ps |grep tomcat8-1

 备注：tomcat 的自动启动命令可以用 ENTRYPOINT ["/usr/local/tomcat8/bin/catalina.sh", "run"]

扩展：用Go代码写dockerfile

  1. 安装 go 语言 [root@karen ~]# mkdir test [root@karen ~]# cd test [root@karen test]# yum install go -y 2.创建源码文件 
    
[root@karen test]# vi main.go
package main

import ( "net/http"

"github.com/gin-gonic/gin"

)

func statusOKHandler(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"status": "success~welcome to study"}) }

func versionHandler(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"version": "v1.1版本"}) }

func main() { router := gin.New() router.Use(gin.Recovery()) router.GET("/", statusOKHandler) router.GET("/version", versionHandler) router.Run(":8080") }

3.Go mod 初始化项目
```shell
[root@karen test]# go mod init test
#设置代理
[root@karen test]# go env -w GOPROXY=https://goproxy.cn,direct
[root@karen test]# go mod tidy

上述命令执行后会将需要的包下载下来

构建源码

[root@karen test]# CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o k8s-demo main.go 4.编写dockerfile文件

[root@karen test]# cat dockerfile
FROM alpine
WORKDIR /data/app
ADD k8s-demo /data/app
CMD ["/bin/sh","-c","./k8s-demo"]

5.构建镜像 [root@karen test]# docker build -t karen/k8sdemo:v1 -f ./dockerfile . 6.运行镜像 [root@karen test]# docker run -d --name go -p 30180:8080 karen/k8sdemo:v1 7.访问go容器 可以在根物理机同网段的其他机器或者浏览器访问karen机器的ip:30180，就可以把请求代理到go容器了

扩展：用python代码写dockerfile

1.获取应用程序代码 把hello-python.tar.gz压缩包上传到k8s控制节点karen的root下，手动解压

[root@karen app]#tar zxvf hello-python.tar.gz
[root@karen app]#cd /root/hello-python/app

备注：requirements.txt文件包含main.py所需的包列表，pip将使用它来安装Flask库。 2.创建dockerfile

[root@karen app]# cat dockerfile
FROM python:3.7    #从Docker Hub获取3.7版本的官方Python基本镜像
RUN mkdir /app     #在镜像中，创建一个名为app的目录
WORKDIR /app       #将工作目录设置为新的app目录
ADD . /app/        #将本地目录的内容复制到该新文件夹，并将其复制到镜像中。
RUN /usr/local/bin/python -m pip install --upgrade pip     
RUN pip install -r requirements.txt        #运行pip安装程序（就像我们前面做的那样），将需求拉入镜像中。
EXPOSE 5000                                #通知Docker容器监听端口5000
CMD ["python","/app/main.py"]              #配置启动命令，使其在容器启动时使用

3.构建镜像 [root@karen app]# docker pull python:3.7 [root@karen app]# docker build -t="hello-python:v1" -f ./dockerfile . 4.基于镜像运行python代码 [root@karen app]# docker run -d --name python -p 30050:5000  hello-python:v1 5.访问python容器 可以在根物理机同网段的其他机器或者浏览器访问karen机器的ip:30050，就可以把请求代理到python容器了

页面列表

ITEM_HTML