day00-容器

大纲

第一章：容器技术概述
第二章：docker容器引擎的安装部署
第三章：docker的镜像管理
第四章：docker的基本操作
第五章：docker的高级操作
第六章：docker file详解
第七章：综合实验
第八章：docker的网络模型

第一章：容器技术概述

容器本质是承东西+做隔离

pid=1的进程是init的进程
image
进程没有做到隔离，希望做到隔离，互不影响（借助容器思维）

image

可以用虚拟化技术解决这个隔离问题，但是开销要大一些
image

容器引擎
image

1.1 应用与应用的隔离（应用的容器化封装）

依赖namespace资源隔离技术（以下6个维度的隔离技术）
pid，在各自的容器中可以相同的编号
网络设备，协议栈都是隔离的，在自己的容器中可以是相同的端口号，相同网卡编号
IPC，进程之间的通信，隔离的2个进程要通信，怎么做？共享内存，共享消息队列
mount，文件系统，各自独立的文件系统，独立的根
uts，有自己的主机名和主机域
user，操作系统进程的用户和用户组，相互隔离（内核3.8以上才实现）
image

1.2 chroot（1979年）

切根，实现了2个应用程序在文件系统上是隔离的

1.3 cgroups（2007年）

操作系统内核，控制你可以使用独立的cpu资源，内存资源，文件系统资源

1.4 lxc（2008年）

容器在生产上

1.5 docker（2013年）

一统容器发展的优势，简单，快捷，高效，便捷，统一

docker基于容器技术，轻量级虚拟化解决方案，完美实现了以上6个维度的隔离
docker是一个引擎，把linux的namespace，cgroup等底层技术封装抽象，为用户提供了创建和管理容器的便捷命令行和api。docker是基于go语言，封装了namespace和cgroup技术

对比
image

第二章：docker引擎的安装部署

EE及CE，2个版，一个企业版，一个社区版

2.1 环境准备

准备centos7.6的虚拟机
内核版本要保证在3.10以上，

genenforce保持关闭
systemctl stop firewalld
外网可以ping通，yum的epel源配置好

curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
yum install epel-release -y
yum install -y yum-utils
yum list docker --show-duplicates

epel源中有docker可以直接使用
image

但是装docker-ce就需要依赖docker-ce的yum源了

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum list docker-ce --show-duplicates

image

2.2 安装docker-ce

yum install docker-ce -y

image

1.开机自启动docker
systemctl enable docker
2.开启docker引擎
systemctl start docker
3.配置docker
mkdir -p /etc/docker
vim /etc/docker/daemon.json

{
    "graph":"/data/docker",
    "storage-driver":"overlay2",
    "insecure-registries":[
        "registry.access.redhat.com",
        "quay.io"
    ],
    "registry-mirrors":[
        "https://q2gr04ke.mirror.aliyuncs.com"
    ],
    "bip":"172.7.5.1/24",
    "exec-opts":[
        "native.cgroupdriver=systemd"
    ],
    "live-restore":true
}

配置说明:
graph:docker的工作目录，里面存containers及images
storage-driver:存储驱动使用overlay2
insecure-registries:不安全的registries,里面的registry不需要证书就可以来回拉取镜像
registry-mirrors:阿里云的加速源
bip:docker网络建议使用172.7.5.0/24（容器的地址和主机地址有一个对应关系）
exec-opts:启动的时候额外参数,cgroupdriver使用systemd,默认docker的cgroupdriver是cgroupfs,而k8s建议使用systemd
live-restore:容器引擎死掉了。容器本身还活着。
4.重启docker引擎
systemctl restart docker
如果重启失败可以systemctl reset-failed docker.service 重置docker服务
5.查看docker info
6.启动第一个hello-world的镜像
docker run hello-world
image

unable to find image 'hello-world:latest' locally 我不能在本地找到一个名为hello-world:latest的镜像
1b930d010525: Pull complete 去拉镜像
Status : Downloaded newer image for hello-world:latest 已经下载完成这个hello-world:latest镜像了
docker引擎是典型的cs架构软件

第三章:docker的镜像管理

docker的核心架构
image
（1）镜像是容器的模板
（2）容器是镜像实例化而来的，容器也可以提交固化成镜像
（3）镜像和仓库是可以推送和拉取的

镜像的结构
${registry_name}/${repository_name}/${image_name}😒{tag_name}
远端注册的地址/仓库名字/镜像的名字/标签的名字（传统意义上都用版本号作为镜像的标签）
例如
docker.io/library/alpine:3.10.1

3.1仓库dockerhub

https://hub.docker.com
类似于github这种东西
sign up 注册账户405186254，邮箱405186254@qq.com

image
image

免费的respository必须是公开的

3.2 虚拟机上登录docker hub

docker login docker.io
image
登录完的信息放哪了？/root/.docker/config.json

{
	"auths": {
		"https://index.docker.io/v1/": {
			"auth": "NDA1MTg2MjU0OkhieXd5ODA2MTAyMCEh"
		}
	}
}

base64转码的
echo "NDA1MTg2MjU0OkhieXd5ODA2MTAyMCEh" | base64 -d

3.3 搜索镜像

docker search alpine
网站搜索alpine
image

3.4 下载镜像

docker pull alpine
下载latest的镜像
镜像结构：docker.io/library/alpine:latest
image

下载指定tag,现在有3.13.6
docker pull alpine:3.13.6
docker pull docker.io/library/alpine:3.10.1

3.5 查看本地镜像

docker images
image

3.6 给镜像打标签

给镜像id为12adea71a33b的镜像（alpine的3.13.6版本）打个标签
docker tag 12adea71a33b docker.io/405186254/alpine:v3.13.6
image

docker tag 12adea71a33b 405186254/alpine:latest

3.7 推送镜像

将刚才打好标签的镜像推送过去
docker push docker.io/405186254/alpine:v3.13.6
docker push docker.io/405186254/alpine:latest
image
docker.hub上查看镜像
image
image

3.8 删除镜像

docker rmi docker.io/405186254/alpine:latest
image

彻底删除镜像,强制删除
docker rmi -f 12adea71a33b

重新拉镜像
docker pull docker.io/405186254/alpine:latest
image

3.9 镜像的特性

image
基于aufs管理镜像的，分层结构
底层bootfs：整个docker镜像底层依赖的库，和内核交互的玩意
真正推送的时候是增量推送的，base image是有自己的image id的
底包很大的话，同步就增量同步了。
看层怎么设计的，增量部分

第四章：docker的基本操作

容器是镜像实例化而来的

4.1 查看本地容器

docker ps -a
image

4.2 启动容器

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
OPTIONS:选项
-i:启动一个可交互式的容器，并持续打开标准输入
-t:表示使用终端关联到容器的标准输入输出上
-d:表示将容器放置后台运行
--rm:退出后及删除容器
--name:表示定义容器的唯一名称
IMAGE:表示要运行的容器镜像
COMMAND：表示启动容器时要运行的命令

docker run -it alpine:latest /bin/sh

image
使用exit命令行退出，container也退出了

image

image

4.3 非交互的方式启动一个容器,一次性容器

docker run --rm alpine:latest /bin/echo hello
--rm ： 代表执行完命令后就自动删除容器了

4.4 非交互式启动一个后台容器

docker run -d --name myalpine alpine:latest
发现container直接退出了，进程hang不住
没有指定特定命令的话，就自动退出了

docker run -d --name myalpine alpine:latest /bin/sleep 300

4.5 容器里起的进程，能不能在宿主机上被查看到

image
可以

4.6 进入容器

docker exec -it 容器id
docker exec -it 3d91ca7fc2eb /bin/sh

4.7 停掉容器

docker stop 3d91ca7fc2eb

4.8 启动容器

docker start 3d91ca7fc2eb

4.9 重启容器

docker restart 3d91ca7fc2eb

4.10 删除容器

docker rm 3d91ca7fc2eb
docker rm -f 3d91ca7fc2eb 强制删除容器

for i in `docker ps -a | grep -i exit | sed '1d|awk '{print $1}'`
do
    docker rm -f $i
done

4.11 容器自己的文件系统树

里面写个hello到1.txt
实际是把hello 写到了容器的可写层writable
image

4.12 把可写层的修改提交到镜像里,

docker commit -p myalpine 405186254/alpine:with_1.txt

image

4.13 导出/导入镜像

docker images
导出镜像
docker save imageId > alpine:v3.10.3_with_1.txt.tar
导入镜像
docker load < alpine:v3.10.3_with_1.txt.tar
docker tag 镜像id 405186254/alpine:v3.10.3_with_1.txt

4.14 查看容器的日志

docker logs -f 容器id
容器的标准输出读出来

5.docker容器的高级操作

5.1 映射端口

docker run -p 容器外端口:容器内端口
下载ngnix镜像
image
image

5.2 挂载数据卷

docker run -v 容器外目录:容器内目录
宿主机执行

mkdir -p /root/html
cd /root/html
wget www.baidu.com -O index.html

[root@k8s-study html]# docker run -d --rm -d -p82:80 -v /root/html:/usr/share/nginx/html 4037a5562b03
c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193

image

docker inspect 查看容器运行的一些细节

[root@k8s-study html]# docker inspect c3b5fb9945eb
[
    {
        "Id": "c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193",
        "Created": "2021-11-04T09:19:35.416257874Z",
        "Path": "nginx",
        "Args": [
            "-g",
            "daemon off;"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 15190,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2021-11-04T09:19:35.779154566Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:4037a5562b030fd80ec889bb885405587a52cfef898ffb7402649005dfda75ff",
        "ResolvConfPath": "/data/docker/containers/c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193/resolv.conf",
        "HostnamePath": "/data/docker/containers/c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193/hostname",
        "HostsPath": "/data/docker/containers/c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193/hosts",
        "LogPath": "/data/docker/containers/c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193/c3b5fb9945eb261d75cbc0b2e597b90693c600a6570bd07a63d2fa09aefb9193-json.log",
        "Name": "/laughing_wu",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": [
                "/root/html:/usr/share/nginx/html"
            ],
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {
                "80/tcp": [
                    {
                        "HostIp": "",
                        "HostPort": "82"
                    }
                ]
            },
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": true,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/data/docker/overlay2/438030ebafb7fc677a08a79f0b734a28bbe46607e3cdea209de9508b23141d28-init/diff:/data/docker/overlay2/3b3f94566ab0f56f3b4561c8587246c65284575ea69b776e013ddf7ebd88a6e0/diff:/data/docker/overlay2/9bd287523583ed2ea8fd455448b609176365d4e5362d38c03103c426ac7f3d15/diff:/data/docker/overlay2/038bbdb5529bedeef851f402848e03fafd64a7db1c6944e562ee4c4bb01f4b2e/diff",
                "MergedDir": "/data/docker/overlay2/438030ebafb7fc677a08a79f0b734a28bbe46607e3cdea209de9508b23141d28/merged",
                "UpperDir": "/data/docker/overlay2/438030ebafb7fc677a08a79f0b734a28bbe46607e3cdea209de9508b23141d28/diff",
                "WorkDir": "/data/docker/overlay2/438030ebafb7fc677a08a79f0b734a28bbe46607e3cdea209de9508b23141d28/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/root/html",
                "Destination": "/usr/share/nginx/html",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],
        "Config": {
            "Hostname": "c3b5fb9945eb",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "80/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
                "NGINX_VERSION=1.12.2-1~stretch",
                "NJS_VERSION=1.12.2.0.1.14-1~stretch"
            ],
            "Cmd": [
                "nginx",
                "-g",
                "daemon off;"
            ],
            "Image": "4037a5562b03",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "maintainer": "NGINX Docker Maintainers <docker-maint@nginx.com>"
            },
            "StopSignal": "SIGTERM"
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "cbe2ed9c93572f7a0616c3798ccd4db1186344d2ef52e297f228ebcfa31624ae",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {
                "80/tcp": [
                    {
                        "HostIp": "0.0.0.0",
                        "HostPort": "82"
                    },
                    {
                        "HostIp": "::",
                        "HostPort": "82"
                    }
                ]
            },
            "SandboxKey": "/var/run/docker/netns/cbe2ed9c9357",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "1c790bde74bf4a4187077614b15c8489462f1baa883b0e9ecf0df166ec39d9ec",
            "Gateway": "172.7.5.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.7.5.3",
            "IPPrefixLen": 24,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:07:05:03",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "8f91bdf43e668dc020614078ae92e9aa16f855083bbe4ad0069cb2aff405be31",
                    "EndpointID": "1c790bde74bf4a4187077614b15c8489462f1baa883b0e9ecf0df166ec39d9ec",
                    "Gateway": "172.7.5.1",
                    "IPAddress": "172.7.5.3",
                    "IPPrefixLen": 24,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:07:05:03",
                    "DriverOpts": null
                }
            }
        }
    }
]

5.3 传递环境变量

openstack就没有这个功能
可以按照自己想要的方式启动容器
docker run --rm -e E_OPTS=abcdefg HOME=/root
启动前接受一些参数，
云原生主要就是依赖这个，不同项目可能用一个底包，通过不同的环境变量，指定启动不同的jar包
docker run --rm -e E_OPTS=abcdefg 405186254/alpine:latest printenv

5.4 容器内安装软件

yum/apt

5.5 容器的生命周期

  • 检查本地是否存在镜像，如果不存在从远端仓库检索
  • 利用镜像启动容器
  • 分配一个文件系统，只读的镜像层外挂一层可读写层
  • 从宿主机的网桥接口中桥接一个虚拟接口到容器中
  • 从地址池配置一个ip地址给容器
  • 执行用户指定的指令
  • 执行完毕后容器终止

宿主机上是有一个叫做docker0的网卡设备的

用户命令，做为一个前台进程hang在控制台的这种，不退出。容器的生命周期的解释
image

6.DockerFile

6.1 docker镜像的制作途径

image

docker可以自动构建镜像，通过从dockerfile文件中读取指令
dockerfile是一个txt的文本文件，包含了命令，组装这个镜像。
image

6.2 docker file规则

# 为注释
指令(大写) 内容(小写)
尽管指令大小写不铭感，我们建议指令大写，内容小写表示

docker是按照顺序执行dockerfile里的指令集合的

每一个dockerfile第一个非注释行指令必须是FROM指令，用于为镜像文件的构成过程中，指定基准镜像镜像，后续的指令运行于此基准镜像所提供的运行环境中

基准镜像可以是任何可用的镜像文件，默认情况下docker build，会在docker主机本地上查找指定的镜像文件，在本地不存在时，会从docker register上拉取所需镜像文件

6.3 docker 指令USER/WORKDIR

USER ： 用途是指明docker里面主进程init进程，pid为1的进程是用什么用户启动
WORKDIR : 工作目录，相当于cd /usr/share/nginx/html,后面的命令都是在这个目录下执行的
范例
vim /data/dockerfile/Dockerfile

FROM docker.ip/405186254/nginx:v1.12.2
USER nginx
WORKDIR /usr/share/nginx/html

构建镜像
cd /data/dockerfile
docker build . -t docker.io/405186254/nginx:v1.12.2_with_user_workdir
image

启动镜像
docker run --rm -ti 405186254/nginx:v1.12.2_with_user_workdir /bin/bash
image

whoami
pwd

6.4 docker 指令ADD/EXPOSE

add:会了add指令就好，copy指令可以不会,往容器里面放文件和放东西，可以放目录
expose:容器里哪个端口要被暴露出来

FROM docker.io/405186254/nginx:v1.12.2
ADD index.html /usr/share/nginx/html/index.html
EXPOSE 80

将下载的百度首页和Dockerfile放同一级目录里,构建镜像
docker build . -t 405186254/nginx:v1.12.2_with_index_expose

expose怎么使

# docker run --rm --it -P 405186254/nginx:v1.12.2_with_index_expose /bin/bash

docker run --rm -d -P 405186254/nginx:v1.12.2_with_index_expose

宿主机上会起一个端口32768,随机生成一个端口，（-P 就是随机起了一个端口把里面的80端口给代理出来了）
image
实际生产中expose指令很鸡肋的，只是为了讲-P 参数随机生成一个端口，-p是用来在宿主机上生成指定端口。
dockerfile里面的expose指令是和外面的-P指令配合使用的，如果外面使用-p指令的话，里面的expose指令并不生效
image

6.5 docker 指令RUN/ENV

RUN指令是构建镜像时操作的一些东西
yum list bind --show-duplicates
ENV环境变量

FROM centos:7
ENV VER 9.11.4
RUN yum install bind-$VER -y

RUN指令，在构建镜像的时候帮你执行一些指令

docker build . -t 405186254/bind:v9.9.4_with_env_run

docker run --it --rm 405186254/bind:v9.9.4_with_env_run /bin/bash

6.6 docker指令CMD

CMD指令是容器启动时，执行的一些指令,显示的运行在前台

FROM centos:7
RUN yum install httpd -y
CMD ["httpd","-D","FOREGROUND"]

docker build . -t 405186254/httpd:test

docker run -d --rm -p83:80 405186254/httpd:test
docker ps -a

6.7 docker指令ENTRYPOINT指令

容器启动之前做一些初始化配置，或者一些自定义的配置等。通常是一个脚本，然后在脚本里配置相关预定义项.
常用来处理容器初始化的一些动作
每一个docker镜像都有一个默认的cmd命令。会开机默认执行/entrypoint.sh脚本。如果什么都没有就走/bin/bash
自定义cmd > 默认/entrypoint.sh > 默认/bin/sh

自定义entrypoint.sh

#!/bin/bash
# utf-8
/sbin/nginx -g "daemon off;"

FROM centos:7
ADD entrypoint.sh /entrypoint.sh
RUN yum install epel-release -q -y && yum install nginx -y
ENTRYPOINT /entrypoint.sh

用于多个cmd命令，复杂不如写脚本调用
走的还是entrypoint.sh

如果docker run执行的时候，最后接的cmd命令是可以替换掉镜像里最后代的cmd命令的，但是如果用的是entrypoint.sh，没有cmd，是替换不掉的

7.第七章：综合实验

运行一个docker容器，在浏览器打开demo.od.com能访问到百度首页

准备docker镜像
Dockerfile

FROM 405186254/nginx:v1.12.2
USER root
ENV WWW /usr/share/nginx/html
ENV CONF /etc/nginx/conf.d
RUN /bin/cp /usr/share/zoneInfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' > /etc/timezone
WORKDIR $WWW
ADD index.html $WWW/index.html
ADD demo.od.com.conf $CONF/demo.od.com.conf
EXPOSE 80
CMD ["nginx","-g","daemon off;"]

demo.od.com.conf

server {
    listen 80;
	server_name demo.od.com;
	root /usr/share/nginx/html;

}

综合实验，准备一个jar包，直接docker运行这个jar包，访问8000端口内的地址
Dockerfile

FROM centos:6.10
USER root
RUN useradd admin && /bin/rm -f /etc/yum.repos.d/*
WORKDIR /home/admin
ADD Centos-6.repo /etc/yum.repos.d/Centos-6.repo
ADD jdk1.8.0_131 /export/servers/jdk1.8.0_131
ADD k8s-1.0-SNAPSHOT.jar /export/App/k8s-1.0-SNAPSHOT.jar
RUN /bin/cp -rf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' > /etc/timezone && chown admin.admin -R /export && yum install iputils iotop telnet nc iproute net-tools -y
CMD ["/export/servers/jdk1.8.0_131/bin/java","-jar","/export/App/k8s-1.0-SNAPSHOT.jar"]

Centos-6.repo

[base]
name=CentOS-6
failovermethod=priority
baseurl=http://mirrors.sohu.com/centos/6.10/os/x86_64/
gpgcheck=0

7.构建一个镜像，起java进程

Dockerfile

FROM centos:6.10
USER root
RUN useradd admin && /bin/rm -f /etc/yum.repos.d/*
WORKDIR /home/admin
ADD Centos-6.repo /etc/yum.repos.d/Centos-6.repo
ADD jdk1.8.0_131 /export/servers/jdk1.8.0_131
ADD k8s-1.0-SNAPSHOT.jar /export/App/k8s-1.0-SNAPSHOT.jar
RUN /bin/cp -rf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' > /etc/timezone && chown admin.admin -R /export && yum install iputils iotop telnet nc iproute net-tools -y
ADD entrypoint.sh /entrypoint.sh
ENTRYPOINT ["sh","/entrypoint.sh"]

entrypoint.sh

#!/bin/sh
# utf-8
/export/servers/jdk1.8.0_131/bin/java -jar /export/App/k8s-1.0-SNAPSHOT.jar
exec "$@"

8.第八章：docker的网络模型

备注：不建议mysql放docker里，k8s，docker最适合的是那种无状态的服务
1.默认NAT
宿主机上docker0的网络设备去虚拟出来了docker的网络
nat哪配置的呢？是从daemon.json里配置的
image

2.None
不需要docker里有网络设备，不提供网络服务，只用到计算资源和存储资源

image

3.Host
会用到

docker和宿主机在同一个网络

docker run -it --rm --net=host xxxxx /bin/bash

image

4.联合网络（k8s用的比较广泛）

两个容器共享一个网络namespace

docker run -it --rm --net container:containerId 405186254/nginx:curl /bin/bash

posted @   SpecialSpeculator  阅读(111)  评论(0)  编辑  收藏  举报
编辑推荐：
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
· 没有源码，如何修改代码逻辑？
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 记一次.NET内存居高不下排查解决与启示
点击右上角即可分享
微信分享提示