# Usage: docker build -t hub.weiyigeek.top/first_tag -f /opt/dockerfile .

#1.第一行必须指定基于的基础镜像
FROM ubuntu

#2.前期操作处理
MAINTAINER weiyigeek weiyigeek@qq.com #会影响实际仓库的拉取
LABEL version="1.0" #容器元信息,帮助信息,Metadata,类似于代码注释
LABEL maintainer="weiyigeek@163.com"

WORKDIR /opt/demo  #切换工作空间(建议使用绝对路径)
ADD /opt/package /data/  # 把本地文件目录添加到镜像中

ENV MYSQL_VERSION 5.6 # 设置一个mysql常量 环境变量,尽可能使用ENV增加可维护性

#3.镜像的操作命令
#RUN指令时对镜像执行跟随的命令,每运行一条RUN指令,镜像添加新的一层并提交;
RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main uiverse" >> /etc/apt/source.list
RUN apt-het update && apt-get install -y nginx \
    net-tools mysql-server="${MYSQL_VERSION}"
RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf

#4.镜像启动时候执行的命令
CMD /usr/sbin/nginx

docker build [选项]
- t ：指定标签信息
--build-arg <参数名>=<值>

# 构建镜像的几种方式:
#1) 指定的Dockfile所在路径为/tmp/docker_builder
$docker build -t [TAG/version] /tmp/docker_builder

#2) 支持从 URL 构建
$docker build https://github.com/twang2218/gitlab-ce-zh.git#:11.1 

#3) 用给定的 tar 压缩包构建
$docker build http://server/context.tar.gz  

#4) 从标准输入中读取 Dockerfile 进行构建
$docker build - < Dockerfile
$cat Dockerfile | docker build -

#5) 从标准输入中读取上下文压缩包进行构建
$docker build - < context.tar.gz   #标准输入的文件格式还可以是 gzip、bzip2 以及 xz 

# 基础语法
FROM <image> 或者 FROM <image>:<tag>

# 使用案例
FROM alpine
FROM golang:1.9-alpine as builder # 注意：多阶段构建使用 as 来为某一阶段命名

# 基础语法:每个标签一行，由 LABEL 开头加上一个或多个标签对。
LABEL key=<value>

# 使用案例 
# Set one or more individual labels `#`开头的行是注释内容。
LABEL maintainer="WeiyiGeek"
LABEL vendor="ACME Incorporated"
LABEL version=1.1
LABEL com.example.version="0.0.1-beta"
LABEL com.example.release-date="2015-02-12"

# Set multiple labels at once, using line-continuation characters to break long lines
LABEL vendor=ACME\ Incorporated \
      version=1.1 \ 
      com.example.version="0.0.1-beta" \ 
      com.example.release-date="2015-02-12" 

# 基础语法
MAINTAINER key=<value>

# 使用案例
MAINTAINER WeiyiGeek master@weiyigeek.top

# 基础语法
RUN <COMMAND> 或者 RUN ["executable","param1","param2"]

# 使用案例
如：RUN ["/bin/bash","-c","echo Hello"],当命令较长时可以使用\来换行;
RUN apt-get update;\
    apt-get install -y nginx ;\ 
    rm -rf /var/lib/apt/lists/*

#展示了所有关于 apt-get 的建议
#其中 s3cmd 指令指定了一个版本号`1.1.*`。如果之前的镜像使用的是更旧的版本，指定新的版本会导致 apt-get udpate 缓存失效并确保安装的是新版本。
RUN apt-get update && apt-get install -y \
    aufs-tools \
    automake \
    build-essential \
    curl \
    dpkg-sig \
    libcap-dev \
    libsqlite3-dev \
    mercurial \
    reprepro \
    ruby1.9.1 \
    ruby1.9.1-dev \
    s3cmd=1.1.* \
 && rm -rf /var/lib/apt/lists/*

FROM ubuntu:18.04
RUN apt-get update
RUN apt-get install -y curl

#方式1.使用`RUN apt-get update && apt-get install -y` 可以确保你的`Dockerfiles`每次安装的都是包的最新的版本，而且这个过程不需要进一步的编码或额外干预。

#方式2.固定版本会迫使构建过程检索特定的版本来达到 `cache-busting`目的，而不管缓存中有什么，该项技术也可以减少因所需包中未预料到的变化而导致的失败。
RUN apt-get update && apt-get install -y \
    package-bar \
    package-baz \
    package-foo=1.3.*

#基础语法
#CMD指令有如下三种格式

#exec格式
CMD ["executable","param1","param2"] 
#为ENTRYPOINT提供参数
CMD ["param1","param2"]
#shell格式,在/bin/bash中执行提供给需要交互的应用
CMD command param1 param2  


# 基础示例
#(1)如果创建镜像的目的是为了部署某个服务(比如 Apache)
CMD ["apache2", "-DFOREGROUND"]
#(2)如果使用 shell 格式的话,实际的命令会被包装为 sh -c 的参数的形式进行执行。比如：
CMD echo $HOME #在实际执行中,会将其变更为： CMD [ "sh", "-c", "echo $HOME" ]

#基础语法
EXPOSE <port> [<port>...]

#基础示例
# (1) 告诉dokcer服务端容器暴露的端口号,供互联系统使用; 也就是 docker run -P 时会自动随机映射 EXPOSE 的端口。
EXPOSE 22 80 8443 

# (2) 例如提供 Apache web 服务的镜像应该使用 80，而提供 MongoDB 服务的镜像使用 27017 
EXPOSE 80 27017

# (3) 指定一个范围
EXPOSE 30000-40000

# 基础语法
ENV <key> <value>   #会被后续的RUN指令使用,并在容器运行时保持;

# 基础示例
#方式1: 如RUN还是运行时的应用，都可以直接使用这里定义的环境变量。
ENV PG_MAJOR 9.3
ENV PATH /usr/local/postgres-\$PG_MAJOR/bin:$PATH  
RUN curl -SL http://example.com/postgre-$PG_MAJOR.tar.xz  && ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH

#方式2: 将所有的环境变量定义在一条ENV语句中
ENV VERSION=1.0 DEBUG=on \
    NAME="Happy Feet"

ARG <参数名> [=<默认值>] 

# 调用方式与Shell中一致
${IMG_PATH}

# 基础语法
ADD <src> <dest>

# 基础示例
# (1)最佳用例是将本地tar文件自动提取到镜像中
ADD rootfs.tar.xz

# (2)下载后的文件权限自动设置为 600 这个自动解压缩的功能非常有用；
ADD ubuntu-xenial-core-cloudimg-amd64-root.tar.gz 
ADD --chown=55:mygroup files* /mydir/
ADD $PWD /opt/blog/  #复制到目录之中

#你可以在文件提取完之后删掉不再需要的文件来避免在镜像中额外添加一层
#比如尽量避免下面的用法：
ADD http://example.com/big.tar.xz /usr/src/things/
RUN tar -xJf /usr/src/things/big.tar.xz -C /usr/src/things
RUN make -C /usr/src/things all

#而是应该使用下面这种方法：由于使用的管道操作，所以没有中间文件需要删除。
RUN mkdir -p /usr/src/things \
    && curl -SL http://example.com/big.tar.xz \
    | tar -xJC /usr/src/things \
    && make -C /usr/src/things all

# 基础语法
COPY <src> <dest>
# 选项
--from=多阶段构建的镜像名称 #FROM Alpine AS [名称]

# 常规方式
COPY package.json /usr/src/app/
#<源路径> 可以是多个,甚至可以是通配符
COPY hom* /mydir/
COPY hom?.txt /mydir/

# 选项来改变文件的所属用户及所属组。
COPY --chown=55:mygroup files* /mydir/
COPY --from=0 /go/src/github.com/go/helloworld/app .  #多阶段构建，从上一阶段的镜像中复制文件
COPY --from=nginx:latest /etc/nginx/nginx.conf /nginx.conf  #复制任意镜像中的文件（但需要指定镜像名称

# 基础示例
#exec格式推荐的格式
ENTRYPOINT ["executable","param1","param2"]
#shell格式:使用ENTRYPONT指令并不可被docker run提供的参数覆盖(与CMD不同之处)
ENTRYPOINT command param1 param2    #shell中执行

# 基础示例
# 1.例如下面的示例镜像提供了命令行工具 s3cmd:
ENTRYPOINT ["s3cmd"]
CMD ["--help"]
#现在直接运行该镜像创建的容器会显示命令帮助: $ docker run s3cmd
#或者提供正确的参数来执行某个命令：$ docker run s3cmd ls s3://mybucket

# 2.使用ENTRYPOINT 的exec形式来设置相对稳定的默认命令和参数，然后使用任何形式的CMD指令来设置可能发生变化的参数。
FROM alpine
ENTRYPOINT ["top", "-b"]
CMD ["-c"]
#当运行容器是，可以看到只有一个top进程在运行：
$ docker run -it --rm --name alpine:test top -H
PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
  1 root      20   0   19744   2336   2080 R  0.0  0.1   0:00.04 top
$ docker exec -it alpine:test ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  2.6  0.1  19752  2352 ?        Ss+  08:24   0:00 top -b -H
root         7  0.0  0.1  15572  2164 ?        R+   08:25   0:00 ps aux


# 3.ENTRYPOINT指令的shell格式
#通过为ENTRYPOINT指定文本格式的参数，此参数将在`/bin /sh -c` 中进行执行
#该形式将使用shell处理而不是shell环境变量，并且将忽略任何的CMD或docker run运行命令行参数。
FROM alpine
ENTRYPOINT exec top -b

#例如:Postgres 官方镜像使用下面的脚本作为 ENTRYPOINT;
#!/bin/bash
set -e
if [ "$1" = 'postgres' ]; then
    chown -R postgres "$PGDATA"
    if [ -z "$(ls -A "$PGDATA")" ]; then
        gosu postgres initdb
    fi
    exec gosu postgres "$@"
fi
exec "$@"

COPY ./docker-entrypoint.sh /
ENTRYPOINT ["/docker-entrypoint.sh"]

$ docker run postgres
$ docker run postgres postgres --help
$ docker run --rm -it postgres bash #启动另外一个完全不同的工具，比如 Bash：

#下面是是启动一个nginx的例子端口为80：
docker run -i -t --rm -p 80:80 nginx
#例如，docker run <Image> -d 将通过-d 参数传递到入口点
#例如，docker run –entrypoint 字段覆盖"ENTRYPOINT "指令

FROM debian:stable
RUN apt-get update && apt-get install -y --force-yes apache2
EXPOSE 80 443
VOLUME ["/var/www", "/var/log/apache2", "/etc/apache2"]
ENTRYPOINT ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]

# 基础示例:
VOLUME ["<路径1>", "<路径2>"...] 

# 实际示例:
#一般用来存放数据和需要保持的数据等,在运行的时候我们就可以利用 -v /Store/data(宿主机):/date(容器),数据就可以直接存在在宿主机上面;
VOLUME ["/data"]

# 方式1
RUN groupadd -r postgres -g 1001 && useradd -r -g postgres postgres -u 1001
# 方式2
RUN useradd -r -u 1001 -U postgres

# 基础示例
#(1) 当服务不需要管理员权限时,可以通过该命令指定运行用户,并且可以在之前创建所需要的用户
USER daemon 

#(2)要临时获取管理员权限可以使用gosu而不使用sudo;
#USER 只是帮助你切换到指定用户而已，这个用户必须是事先建立好的，否则无法切换。
RUN groupadd -r postgres && useradd -r -g postgres postgres  
USER postgres  

# 基础示例
#(1)为后续的RUN CMD ENTRYPOINT 指令配置工作目录
WORKDIR /path/to/workdir  

#(2)使用多个WORKDIR指令，如果后续命令参数是相对路径，则会基于首个绝对路径进行拼接。
WORKDIR /a
WORKDIR b
WORKDIR C
RUN pwd  #最终路径是/a/b/c

FROM node:slim
RUN mkdir /app
WORKDIR /app
COPY ./package.json /app
RUN [ "npm", "install" ]
COPY . /app/
CMD [ "npm", "start" ]

FROM my-node
RUN mkdir /app
WORKDIR /app
CMD [ "npm", "start" ]

FROM node:slim
COPY ./package.json /app
RUN [ "npm", "install" ]
COPY . /app/

#当我们需要在一个镜像中操作添加更新然后打包放在子项目中，在以后的日子里都以此镜像来更新创建容器，为了方便版本控制所以引入了ONBUILD指令
FROM node:slim
RUN mkdir /app
WORKDIR /app
ONBUILD COPY ./package.json /app
ONBUILD RUN [ "npm", "install" ]
ONBUILD COPY . /app/
CMD [ "npm", "start" ]

#在构建基础镜像的时候 -t my-node，这三行ONBUILD并不会被执行，然后各个项目的 Dockerfile 就变成了简单地：
# 例如，执行docker build 并不会执行ONBUILD ，只有在使用my-node-onbuild:latest 作为基础镜像时才触发。
Docker build -t weiyigeek/my-node-onbuild:latest .

FROM my-node
#当在各个项目目录中，用这个只有一行的 Dockerfile 构建镜像时，之前基础镜像的那三行 ONBUILD 就会开始执行，成功的将当前项目的代码复制进镜像、并且针对本项目执行 npm install，生成应用镜像。

# 实际示例
STOPSIGNAL signal

# 实际示例
SHELL ["/bin/sh","-c"] 
SHELL ["powershell","-command"]

# 实践使用示例
FROM microsoft/nanoserver
SHELL ["powershell","-command"]
RUN New-Item -ItemType Directory C:\Example
ADD Execute-MyCmdlet.ps1 c:\example\
RUN c:\example\Execute-MyCmdlet -sample 'hello world'

# 基础语法
#命令的返回值决定了该次健康检查的成功与否：0：成功；1：失败；2：保留，不要使用这个值。
HEALTHCHECK [选项] CMD <命令>
# 选项：
--interval=<间隔>：两次健康检查的间隔，默认为 30 秒；
--timeout=<时长>：健康检查命令运行超时时间，如果超过这个时间本次健康检查就被视为失败默认 30 秒；
--retries=<次数>：当连续失败指定次数后，则将容器状态视为 unhealthy，默认 3 次。

# 如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令
HEALTHCHECK NONE

# Dockerfile 示例
# (1) 设置了每 5 秒检查一次（这里为了试验所以间隔非常短，实际应该相对较长），如果健康检查命令超过 3 秒没响应就视为失败
# 并且使用 curl -fs http://localhost/ || exit 1 作为健康检查命令。
FROM nginx
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
HEALTHCHECK --interval=5s --timeout=3s --retries=5 \
  CMD curl -fs http://localhost/ || exit 1

# (2) 使用 docker build 来构建这个镜像并启动;
docker build -t myweb:v1 .
$ docker run -d --name web -p 80:80 myweb:v1

# (3) 最初的状态为 (health: starting)在等待几秒钟后，再次 docker container ls 就会看到健康状态变化为了 (healthy);
# 如果健康检查连续失败超过了重试次数，状态就会变为 (unhealthy)。
$ docker container ls
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                    PORTS               NAMES
03e28eb00bd0        myweb:v1            "nginx -g 'daemon off"   18 seconds ago      Up 16 seconds (healthy)   80/tcp, 443/tcp     web

# (4) 健康检查命令的输出（包括 stdout 以及 stderr）都会被存储于健康状态里，可以用 docker inspect 来查看
$ docker inspect --format '{{json .State.Health}}' web | python -m json.tool
{
    "FailingStreak": 0,
    "Log": [
        {
        "End": "2019-12-30T14:35:37.940957051Z",
        "ExitCode": 0,
        "Output": "<!DOCTYPE html>\n<html>\n<head>\n<title>Welcome to nginx!</title>....",
        "Start": "2019-12-30T14:35:37.780192565Z"
        }
    ],
    "Status": "healthy"
}

RUN/CMD/ENTRYPOINT yum install -y vim  #Shell格式  如$PWD $LANG 宿主机
RUN/CMD/ENTRYPOINT ["apt-get","install","-y","vim"] #EXEC格式

#错误的形式
CMD service nginx start  #发现容器执行后就立即退出了
#会被理解为 
CMD [ "sh", "-c", "service nginx start"] 
#因此主进程实际上是 sh。那么当 service nginx start 命令结束后,sh 也就结束了,sh 作为主进程退出了,自然就会令容器退出。

#正确的做法是直接执行 nginx 可执行文件，并且要求以前台形式运行。比如：
CMD ["nginx", "-g", "daemon off;"]

COPY /opt/package.json /app/  #上下文路径错误或导致构造失败
COPY ./package.json /app/  #COPY 这类指令中的源文件的路径都是相对路
#这并不是要复制执行 docker build 命令所在的目录下的 package.json,也不是复制 Dockerfile 所在目录下的 package.json,而是复制 上下文（context） 目录下的 package.json。

[root@localhost ~]# cat app.py
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)

[root@master home]# ls
    app.py  Dockerfile

FROM python:2.7
LABEL version="1.0"
LABEL maintainer="weiyigeek"
RUN pip install flask
COPY app.py /app/
WORKDIR /app
EXPOSE 8080
CMD ["python","app.py"]

#comment
*/temp*
*/*/temp*
tmp?
~*

docker build -t weiyigeek/flask-hello-docker .
docker image ls  #.查看创建好的images

docker run -d -p 8080:8080 weiyigeek/flask-hello-docker
docker container ls

docker tag weiyigeek/flask-hello-docker   192.168.11.37:5000/peng-flaskweb
docker push 192.168.11.37:5000/peng-flaskweb

# Tomcat]# docker build -t weiyigeek/tomcat:7.0.85-jre8-gbk18030 .
FROM weiyigeek/tomcat:7.0.85-jre8
MAINTAINER WeiyiGeek <master@WeiyiGeek.top>
RUN wget -O /etc/apt/sources.list  http://192.168.10.206:8080/sources.list \
    && apt clean && apt update && apt install -y locales \
    && sed -i 's/# zh_CN.GB18030/zh_CN.GB18030/g' /etc/locale.gen \
    && locale-gen \
    && locale -a \
    && rm -rf /var/cache/apt/*
ENV LANG=zh_CN.gb18030
CMD ["catalina.sh" "run"]

FROM golang:alpine as builder
ARG IMG_PATH=/opt/pics
ARG EXHAUST_PATH=/opt/exhaust
RUN apk update ;\
    apk add alpine-sdk ;\
    git clone https://github.com/webp-sh/webp_server_go /build ;\
    cd /build ;\
    sed -i "s|.\/pics|${IMG_PATH}|g" config.json ;\
    sed -i "s|\"\"|\"${EXHAUST_PATH}\"|g" config.json ;\
    sed -i 's/127.0.0.1/0.0.0.0/g' config.json
WORKDIR /build
RUN go build -o webp-server .

FROM alpine
COPY --from=builder /build/webp-server  /usr/bin/webp-server
COPY --from=builder /build/config.json /etc/config.json
WORKDIR /opt
VOLUME /opt/exhaust
CMD ["/usr/bin/webp-server", "--config", "/etc/config.json"]

#基础镜像
FROM mhart/alpine-node:latest
#作者描述
LABEL maintainer="weiyigeek <weiygeek@qq.com>"
LABEL description="weiyigeek blog"

# 切换工作目录
WORKDIR /opt/web/

#更新alpine软件源和下载git
RUN apk update \ 
 && apk add git \
 && git clone https://gitee.com/WeiyiGeek/blog.git

ENV LANG=en_US.UTF-8 \
  LANGUAGE=en_US:en \
 LC_ALL=en_US.UTF-8

# 重要不能采用cd进行切换
WORKDIR /opt/web/blog/

#下载博客hexo框架与依赖
RUN npm install -g hexo-cli --save \
    && npm install --production --registry=https://registry.npm.taobao.org --save

#对外暴露的端口
EXPOSE 4000 30000-40000

#容器建立好运行的命令
ENTRYPOINT ["hexo", "server"]

$docker run -d -p 80:4000 --name blog weiyigeek/blog
c6059fc19891792ce03304bcf943dccd708e5b8c7565fe86159d3407e23e7530

$docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                  NAMES
c6059fc19891        weiyigeek/blog      "hexo server"       7 seconds ago       Up 5 seconds        0.0.0.0:80->4000/tcp   blog

#!/bin/sh
#该方式构建需要shell文件来进行打包融合
echo Building gcc/helloworld:build

#进行编译环境搭建并编译环境
docker build -t gcc/helloworld:build . -f Dockerfile.build

#创建编译的容器
docker create --name extract go/helloworld:builder
docker cp extract:/gcc/demo/test ./test
docker rm -f extract

echo Building gcc/helloworld:runner

#构建运行时环境
docker build --no-cache -t gcc/helloworld:2 . -f Dockerfile.copy
rm ./test

#include <stdio.h>
int main(void)
{
	printf("Hello World! Dockerfile!\n");
	return 0;
}

# Step1 . 编译阶段-Dockerfile.build
FROM alpine as builder
MAINTAINER weiyigeek <weiyigeek@q.com>
RUN apk update && apk --no-cache add gcc g++
WORKDIR /gcc/demo/
COPY test.c .
RUN gcc test.c -o test

# Step2 . 运行阶段-Dockerfile.run
FROM alpine-c as runer
WORKDIR /gcc/demo/
#复制 builder 阶段成果二进制文件test到 当前镜像之中
COPY --from=0 /gcc/demo/test . 
# 或者 COPY --from=builder /gcc/demo/test . 
CMD ["./test"]

# 项目结构
$ls
mutilDockerfile  test.c

# 构建镜像
$docker build -t weiyigeek/hello:1  -f mutilDockerfile .  #注意上下文
Sending build context to Docker daemon  3.072kB
Step 1/10 : FROM alpine as builder
 ---> 055936d39205
Step 2/10 : MAINTAINER weiyigeek <weiyigeek@q.com>
 ---> Running in 59097e3a8120
Removing intermediate container 59097e3a8120
 ---> 8e796c96a921
Step 3/10 : RUN apk update && apk --no-cache add gcc g++
 ---> Running in 89fca19b761d

$docker run --name hello weiyigeek/hello:1
Hello World! Dockerfile!