docker-k8s

docker

容器

1：什么是容器？

Linux容器是与系统其他部分隔离开的一系列进程，从另一个系统镜像运行，并由该镜像提供支持进程所需的全部文件（环境文件）。

容器镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

来源：https://www.redhat.com/zh/topics/containers/whats-a-linux-container

容器不就是虚拟化吗？

虚拟化使得许多操作系统可同时在单个系统上运行。

容器只能共享操作系统内核,将应用进程与系统其他部分,隔离开。

2：容器和虚拟化的区别

linux容器技术，容器虚拟化和kvm虚拟化的区别

kvm虚拟化：需要硬件的支持，需要模拟硬件，可以运行不同的操作系统，启动时间分钟级(开机启动流程)

容器虚拟化：不需要硬件的支持。不需要模拟硬件，共用宿主机的内核，启动时间秒级(没有开机启动流程)

总结：

（1）与宿主机使用同一个内核，性能损耗小；

（2）不需要指令级模拟；

（3）容器可以在CPU核心的本地运行指令，不需要任何专门的解释机制；

（4）避免了准虚拟化和系统调用替换中的复杂性；

（5）轻量级隔离，在隔离的同时还提供共享机制，以实现容器与宿主机的资源共享。

3:容器技术的发展过程：

1）:chroot技术，新建一个子系统

参考资料：https://www.ibm.com/developerworks/cn/linux/l-cn-chroot/

1：使用chroot监狱限制SSH用户访问指定目录和使用指定命令

https://linux.cn/article-8313-1.html

linux容器(lxc)

linux container(namespaces 网络命名空间隔离环境及cgroups 资源限制)

##需要使用epel源

#安装epel源

yum install epel-release -y

#编译epel源配置文件

vi /etc/yum.repos.d/epel.repo

[epel]
name=Extra Packages for Enterprise Linux 7 - $basearch
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/$basearch
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-7&arch=$basearch
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7
[epel-debuginfo]
name=Extra Packages for Enterprise Linux 7 - $basearch - Debug
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/$basearch/debug
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-debug-7&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7
gpgcheck=1
[epel-source]
name=Extra Packages for Enterprise Linux 7 - $basearch - Source
baseurl=https://mirrors.tuna.tsinghua.edu.cn/epel/7/SRPMS
#mirrorlist=https://mirrors.fedoraproject.org/metalink?repo=epel-source-7&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-7
gpgcheck=1

##安装lxc

yum install lxc-* -y

yum install libcgroup* -y

yum install bridge-utils.x86_64 -y

##桥接网卡

[root@controller ~]# cat /etc/sysconfig/network-scripts/ifcfg-eth0

TYPE=Ethernet

BOOTPROTO=none

NAME=eth0

DEVICE=eth0

ONBOOT=yes

BRIDGE=br0

[root@controller ~]# cat /etc/sysconfig/network-scripts/ifcfg-br0

TYPE=Bridge

BOOTPROTO=static

NAME=br0

DEVICE=br0

ONBOOT=yes

IPADDR=10.0.0.11

NETMASK=255.255.255.0

GATEWAY=10.0.0.254

DNS1=223.5.5.5

##修改lxc默认配置

vi /etc/lxc/default.conf

修改第2行为：lxc.network.link = br0

##启动cgroup

systemctl start cgconfig.service

##启动lxc

systemctl start lxc.service

##创建lxc容器

方法1:

lxc-create -t download -n centos6 -- --server mirrors.tuna.tsinghua.edu.cn/lxc-images -d centos -r 6 -a amd64

方法2：

lxc-create -t centos -n test

#####为lxc容器设置root密码：

[root@controller ~]# chroot /var/lib/lxc/centos6/rootfs passwd

Changing password for user root.

New password:

BAD PASSWORD: it is too simplistic/systematic

BAD PASSWORD: is too simple

Retype new password:

passwd: all authentication tokens updated successfully.

##为容器指定ip和网关

vi /var/lib/lxc/centos7/config

lxc.network.name = eth0

lxc.network.ipv4 = 10.0.0.111/24

lxc.network.ipv4.gateway = 10.0.0.254

##启动容器

lxc-start -n centos7

docker容器

Docker是通过内核虚拟化技术（namespaces及cgroups cpu、内存、磁盘io等）来提供容器的资源隔离与安全保障等。由于Docker通过操作系统层的虚拟化实现隔离，所以Docker容器在运行时，不需要类似虚拟机（VM）额外的操作系统开销，提高资源利用率。

docker的主要目标是"Build,Ship and Run any App,Angwhere",构建，运输，处处运行

构建：做一个docker镜像

运输：docker pull

运行：启动一个容器

每一个容器，他都有自己的文件系统rootfs.

kvm解决了硬件和操作系统之间的依赖

docker解决了软件和操作系统环境之间的依赖，能够让独立服务或应用程序在不同的环境中，得到相同的运行结果。

docker容器是一种轻量级、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同的方式运行。开发人员在自己笔记本上创建并测试好的容器，无需任何修改就能够在生产系统的虚拟机、物理服务器或公有云主机上运行。

docker的安装

安装

wget -O /etc/yum.repos.d/docker-ce.repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo
sed -i 's#download.docker.com#mirrors.ustc.edu.cn/docker-ce#g' /etc/yum.repos.d/docker-ce.repo
yum install docker-ce -y

docker的主要组成部分

docker是传统的CS架构分为docker client和docker server,向mysql一样

命令：docker version

[root@controller ~]# docker version

Client:

Version: 17.12.0-ce

API version: 1.35

Go version: go1.9.2

Git commit: c97c6d6

Built: Wed Dec 27 20:10:14 2017

OS/Arch: linux/amd64

Server:

Engine:

Version: 17.12.0-ce

API version: 1.35 (minimum version 1.12)

Go version: go1.9.2

Git commit: c97c6d6

Built: Wed Dec 27 20:12:46 2017

OS/Arch: linux/amd64

Experimental: false

docker info（如果要做监控）

###设置docker远程执行

systemd详解：http://www.ruanyifeng.com/blog/2016/03/systemd-tutorial-part-two.html

####在linux-node1：

vim /usr/lib/systemd/system/docker.service

ExecStart=/usr/bin/dockerd -H unix:///var/run/docker.sock -H tcp://10.0.0.11:2375

systemctl daemon-reload

systemctl restart docker.service

ps -ef检查

####在linux-node2：

wget -O /etc/yum.repos.d/docker-ce.repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo

sed -i 's#download.docker.com#mirrors.ustc.edu.cn/docker-ce#g' /etc/yum.repos.d/docker-ce.repo

yum install docker-ce -y

docker -H 10.0.0.11 info

docker主要组件有：镜像、容器、仓库

启动容器必须需要一个镜像，仓库中只存储镜像

安装Nginx步骤：

官网下载Nginx源码包

创建Nginx用户

编译安装

修改配置文件，

启动

6：启动第一个容器

docker run -d -p 80:80 nginx

run（创建并运行一个容器）

-d 放在后台

-p 端口映射

nginx docker镜像的名字

7：docker的镜像管理

搜索镜像

docker search

选镜像的建议：

1，优先考虑官方

2，starts数量多

获取镜像

docker pull（push）

镜像加速器：阿里云加速器，daocloud加速器，中科大加速器，Docker 中国官方镜像加速：https://registry.docker-cn.com

docker pull centos:6.8（没有指定版本，默认会下载最新版）

##配置docker镜像加速

vi /etc/docker/daemon.json

{

"registry-mirrors": ["https://registry.docker-cn.com"]

}

##第三方docker镜像仓库，使用方法：

docker pull index.tenxcloud.com/tenxcloud/httpd:latest

docker的使用

查看镜像

docker images

删除镜像

docker rmi 例子：docker image rm centos:latest

导出镜像

docker save 例子：docker image save centos > docker-centos7.4.tar.gz

导入镜像

docker load 例子：docker image load -i docker-centos7.4.tar.gz

docker的容器管理

docker容器管理

docker run -d -p 80:80 nginx

run（创建并运行一个容器）

-d 放在后台

-p 端口映射

-v 源地址(宿主机):目标地址(容器)

nginx docker镜像的名字

docker run -it --name centos6 centos:6.8 /bin/sh

-it 分配交互式的终端

--name 指定容器的名字

/bin/sh覆盖容器的初始命令

启动容器

docker run image_name

docker run -it image_name CMD

docker run ==== docker create + docker start

停止容器

docker stop CONTAINER_ID

杀死容器

docker kill container_name

查看容器列表

docker ps

docker ps –a

进入容器

*** docker exec （会分配一个新的终端tty）

docker exec -it 容器id或容器名字 /bin/bash

docker attach（使用同一个终端）

docker attach [OPTIONS] CONTAINER

nsenter(安装yum install -y util-linux)

删除容器

docker rm

批量删除容器

docker rm -f `docker ps -a -q`

总结：docker容器内的第一个进程必须一直处于前台运行的状态（必须夯住），否则这个容器，就会处于退出状态！

docker容器的网络访问

指定映射(docker 会自动添加一条iptables规则来实现端口映射)

-p hostPort:containerPort

-p ip:hostPort:containerPort

-p ip::containerPort(随机端口)

-p hostPort:containerPort:udp

-p 81:80 –p 443:443

随机映射

docker run -P 80（随机端口）

docker的数据卷管理

/usr/share/nginx/html

数据卷(文件或目录)

-v /data

-v src（宿主机的目录）:dst（容器的目录）

数据卷容器

--volumes-from

docker容器保存为镜像

docker commit 容器id或者容器的名字新的镜像名字[:版本号可选]

1）：基于容器制作镜像

docker run -it centos:6.8

######

yum install httpd

yum install openssh-server

/etc/init.d/sshd start

vi /init.sh

#!/bin/bash

/etc/init.d/httpd start

/usr/sbin/sshd -D

chmod +x /init.sh

2）将容器提交为镜像

docker commit boy centos6-ssh-httpd:v1

3）测试镜像功能是否可用

docker 里面启动服务报错

Failed to get D-Bus connection: Operation not permitted

解决办法

启动时加

docker run -itd -p 2202:22 -p 8081:80 -p 3346:3306 -p 4431:443 -h docker02 --name docker02 --privileged=true centos7:v2 /usr/sbin/init

dockerfile自动构建docker镜像

dockerfile主要组成部分：

基础镜像信息 FROM：centos:6.8

制作镜像操作指令 RUN yum install openssh-server -y

容器启动时执行指令CMD ["/bin/bash"]

dockerfile常用指令：

FROM 这个镜像的妈妈是谁？（指定基础镜像）

MAINTAINER 告诉别人，谁负责养它？（指定维护者信息，可以没有）

RUN 你想让它干啥（在命令前面加上RUN即可）

ADD 给它点创业资金（COPY文件，会自动解压）

WORKDIR 我是cd,今天刚化了妆（设置当前工作目录）

VOLUME 给它一个存放行李的地方（设置卷，挂载主机目录）

EXPOSE 它要打开的门是啥（指定对外的端口）(-P 随机端口)

CMD 奔跑吧，兄弟！（指定容器启动后的要干的事情）（容易被替换）

dockerfile其他指令：

COPY 制文件

ENV 环境变量

ENTRYPOINT 容器启动后执行的命令（无法被替换，启容器的时候指定的命令，会被当成参数）

参考其他的dockerfile

官方dockerfile或者时速云镜像广场

13：docker镜像的分层（kvm 链接克隆，写时复制的特性）

14:.容器间的互联（--link 是单方向的！！！）

docker run -d -p 80:80 nginx

docker run -it --link mysql -d -p 8080:80 --name nginx nginx:latest /bin/bash

ping web01

利用docker 镜像搭建WordPress

docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d -p 3306:3306 mysql:5.7

docker run --name wordpress --link mysql -d -p 8080:80 wordpress:latest

使用docker运行zabbix-server

docker run --name mysql-server -t \

-e MYSQL_DATABASE="zabbix" \

-e MYSQL_USER="zabbix" \

-e MYSQL_PASSWORD="zabbix_pwd" \

-e MYSQL_ROOT_PASSWORD="root_pwd" \

-d mysql:5.7 \

--character-set-server=utf8 --collation-server=utf8_bin

docker run --name zabbix-java-gateway -t \

-d zabbix/zabbix-java-gateway:latest

docker run --name zabbix-server-mysql -t \

-e DB_SERVER_HOST="mysql-server" \

-e MYSQL_DATABASE="zabbix" \

-e MYSQL_USER="zabbix" \

-e MYSQL_PASSWORD="zabbix_pwd" \

-e MYSQL_ROOT_PASSWORD="root_pwd" \

-e ZBX_JAVAGATEWAY="zabbix-java-gateway" \

--link mysql-server:mysql \

--link zabbix-java-gateway:zabbix-java-gateway \

-p 10051:10051 \

-d zabbix/zabbix-server-mysql:latest

docker run --name zabbix-web-nginx-mysql -t \

-e DB_SERVER_HOST="mysql-server" \

-e MYSQL_DATABASE="zabbix" \

-e MYSQL_USER="zabbix" \

-e MYSQL_PASSWORD="zabbix_pwd" \

-e MYSQL_ROOT_PASSWORD="root_pwd" \

--link mysql-server:mysql \

--link zabbix-server-mysql:zabbix-server \

-p 80:80 \

-d zabbix/zabbix-web-nginx-mysql:latest

docker registry

##普通的registry

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry

docker push index.tenxcloud.com/google_containers/busybox

1：10.0.0.11:5000/centos6-sshd:v3(手动给它打tag)

2：vi /etc/docker/daemon.json

{

"registry-mirrors": ["https://registry.docker-cn.com"],

"insecure-registries": ["10.0.0.11:5000"]

}

systemctl restart docker

3.docker push 10.0.0.11:5000/centos6-sshd:v3

##带basic认证的registry

yum install httpd-tools -y

mkdir /opt/registry-var/auth/ -p

htpasswd -Bbn old 123456 >> /opt/registry-var/auth/htpasswd

docker run -d -p 5000:5000 -v /opt/registry-var/auth/:/auth/ -v /opt/myregistry:/var/lib/registry -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd registry

docker-compose(单机版的容器编排工具)

yum install -y python2-pip（需要epel源）

pip install docker-compose

##pip 加速

##详细指令

http://www.jianshu.com/p/2217cfed29d7

cd my_wordpress/

vi docker-compose.yml

version: '3'

services:

db:

image: mysql:5.7

ports:

- 3306:3306

volumes:

- db_data:/var/lib/mysql

restart: always

environment:

MYSQL_ROOT_PASSWORD: 123456

MYSQL_DATABASE: wordpress

MYSQL_USER: wordpress

MYSQL_PASSWORD: 123456

wordpress:

depends_on:

- db

image: wordpress:latest

ports:

- "80"

restart: always

environment:

WORDPRESS_DB_HOST: db:3306

WORDPRESS_DB_USER: wordpress

WORDPRESS_DB_PASSWORD: 123456

volumes:

db_data:

#启动

docker-compose up

#后台启动

docker-compose up -d

18：重启docker服务，容器全部退出的解决办法

方法一：docker run --restart=always

方法二："live-restore": true

docker server配置文件/etc/docker/daemon.json参考

{

"registry-mirrors": ["http://b7a9017d.m.daocloud.io"],

"graph": "/opt/mydocker",

"insecure-registries":["10.0.0.11:5000"],

"live-restore": true

}

19：Docker Machine安装docker

20：Docker网络类型

None：不为容器配置任何网络功能，--net=none

Container：与另一个运行中的容器共享Network Namespace，--net=container:containerID

Host：与主机共享Network Namespace，--net=host

Bridge：Docker设计的NAT网络模型

21：Docker跨主机通信之macvlan

##创建macvlan网络

docker network create --driver macvlan --subnet 172.16.1.0/24 --gateway 172.16.1.1 -o parent=eth1 macvlan_1

##设置eth1的网卡为混杂模式

ip link set eth1 promisc on

##创建使用macvlan网络的容器

docker run -it --network macvlan_1 --ip=172.16.1.3 busybox:latest /bin/sh

作业2：用PIPEWORK为docker容器配置独立IP

Dcoker跨主机通信之overlay

http://www.cnblogs.com/CloudMan6/p/7270551.html

1）准备工作

docker01上：

docker run -d -p 8500:8500 -h consul --name consul progrium/consul -server -bootstrap

docker02、03上：

vim /etc/docker/daemon.json

{

"hosts":["tcp://0.0.0.0:2376","unix:///var/run/docker.sock"],

"registry-mirrors": ["https://registry.docker-cn.com"],

"cluster-store": "consul://10.0.0.11:8500",

"cluster-advertise": "10.0.0.12:2376",

"insecure-registries": ["10.0.0.11:5000"]

}

2）创建overlay网络

docker network create -d overlay ol1

3）启动容器测试

docker run -it --network ol1 --name box02 busybox:latest /bin/sh

docker企业级镜像仓库harbor

https://storage.googleapis.com/harbor-releases/release-1.6.0/harbor-offline-installer-v1.6.0.tgz

第一步：安装docker和docker-compose

第二步：下载harbor-offline-installer-v1.3.0.tgz

第三步：上传到/opt,并解压

第四步：修改harbor.cfg配置文件

hostname = 10.0.0.11

harbor_admin_password = 123456

第五步：执行install.sh

vim /etc/docker/daemon.json

"insecure-registries": ["10.0.0.11"]

###k8s的安装方法

kubernetes 二进制安装

kubeadm 安装

minikube 安装

yum 安装

go编译安装

####制作一个只支持sshd服务的镜像

1):启动一个容器，并修改

docker run -it -p 1022:22 centos:6.8 /bin/bash

yum install openssh-server -y

echo 'root:123456'|chpasswd

/etc/init.d/sshd start

测试：ssh远程登录

2）：将修改后的容器，保存为镜像

docker commit friendly_swartz centos6-ssh

3）测试新镜像，sshd是否可用

docker run -d -p 1122:22 centos6-ssh:latest /usr/sbin/sshd -D

ssh root@10.0.0.11 -p 1122

####制作了一个支持sshd和httpd双服务的镜像

1）：启动一个容器，并修改

docker run -d -p 1122:22 centos6-ssh:latest /usr/sbin/sshd -D

yum install httpd -y

/etc/init.d/httpd start

vi /init.sh

#!/bin/bash

/etc/init.d/httpd start

/usr/sbin/sshd -D

chmod +x /init.sh

2）：将修改后的容器，保存为镜像

docker commit 11bf5984784a centos6-httpd

3）测试新镜像，检测sshd和httpd是否可用

docker run -d -p 1222:22 -p 80:80 centos6-httpd:latest /init.sh

作业：使用Dockerfile完成kodexplorer网盘项目

课前回顾：

Linux容器是与系统其他部分隔离开的一系列进程，从另一个系统镜像rootfs运行，并由该镜像提供支持进程所需的全部文件。

容器镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

1：chroot，ldd

2：lxc namespace(6大命名空间)和cgroup

3：docker和kvm区别，docker镜像基础操作，docker容器日常操作，commit制作镜像，dockfile来自动构建镜像

####docker私有仓库registry

1）启动registry容器

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry registry

2）修改/etc/docker/daemon.json配置文件

{

"registry-mirrors": ["https://registry.docker-cn.com"],

"insecure-registries": ["10.0.0.11:5000"]

}

3）重启docker服务

systemctl restart docker

4）为镜像打标签

docker tag centos:6.8 10.0.0.11:5000/boy/centos:6.8

5）push推送镜像

docker push 10.0.0.11:5000/boy/centos:6.8

k8s

K8S学习

Kubernetes 概述

简介

Kubernetes是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效（powerful）,Kubernetes提供了应用部署，规划，更新，维护的一种机制。

Kubernetes一个核心的特点就是能够自主的管理容器来保证云平台中的容器按照用户的期望状态运行着（比如用户想让apache一直运行，用户不需要关心怎么去做，Kubernetes会自动去监控，然后去重启，新建，总之，让apache一直提供服务），管理员可以加载一个微型服务，让规划器来找到合适的位置，同时，Kubernetes也系统提升工具以及人性化方面，让用户能够方便的部署自己的应用（就像canary deployments）。

现在Kubernetes着重于不间断的服务状态（比如web服务器或者缓存服务器）和原生云平台应用（Nosql）,在不久的将来会支持各种生产云平台中的各种服务，例如，分批，工作流，以及传统数据库。

在Kubenetes中，所有的容器均在Pod中运行,一个Pod可以承载一个或者多个相关的容器，在后边的案例中，同一个Pod中的容器会部署在同一个物理机器上并且能够共享资源。一个Pod也可以包含O个或者多个磁盘卷组（volumes）,这些卷组将会以目录的形式提供给一个容器，或者被所有Pod中的容器共享，对于用户创建的每个Pod,系统会自动选择那个健康并且有足够容量的机器，然后创建类似容器的容器,当容器创建失败的时候，容器会被node agent自动的重启,这个node agent叫kubelet,但是，如果是Pod失败或者机器，它不会自动的转移并且启动，除非用户定义了 replication controller。

用户可以自己创建并管理Pod,Kubernetes将这些操作简化为两个操作：基于相同的Pod配置文件部署多个Pod复制品；创建可替代的Pod当一个Pod挂了或者机器挂了的时候。而Kubernetes API中负责来重新启动，迁移等行为的部分叫做“replication controller”，它根据一个模板生成了一个Pod,然后系统就根据用户的需求创建了许多冗余，这些冗余的Pod组成了一个整个应用，或者服务，或者服务中的一层。一旦一个Pod被创建，系统就会不停的监控Pod的健康情况以及Pod所在主机的健康情况，如果这个Pod因为软件原因挂掉了或者所在的机器挂掉了，replication controller 会自动在一个健康的机器上创建一个一摸一样的Pod,来维持原来的Pod冗余状态不变，一个应用的多个Pod可以共享一个机器。

我们经常需要选中一组Pod，例如，我们要限制一组Pod的某些操作，或者查询某组Pod的状态，作为Kubernetes的基本机制，用户可以给Kubernetes Api中的任何对象贴上一组 key:value的标签，然后，我们就可以通过标签来选择一组相关的Kubernetes Api 对象，然后去执行一些特定的操作，每个资源额外拥有一组（很多） keys 和 values,然后外部的工具可以使用这些keys和vlues值进行对象的检索，这些Map叫做annotations（注释）。

Kubernetes支持一种特殊的网络模型，Kubernetes创建了一个地址空间，并且不动态的分配端口，它可以允许用户选择任何想使用的端口，为了实现这个功能，它为每个Pod分配IP地址。

现代互联网应用一般都会包含多层服务构成，比如web前台空间与用来存储键值对的内存服务器以及对应的存储服务，为了更好的服务于这样的架构，Kubernetes提供了服务的抽象，并提供了固定的IP地址和DNS名称，而这些与一系列Pod进行动态关联，这些都通过之前提到的标签进行关联，所以我们可以关联任何我们想关联的Pod，当一个Pod中的容器访问这个地址的时候，这个请求会被转发到本地代理（kube proxy）,每台机器上均有一个本地代理，然后被转发到相应的后端容器。Kubernetes通过一种轮训机制选择相应的后端容器，这些动态的Pod被替换的时候,Kube proxy时刻追踪着，所以，服务的 IP地址（dns名称），从来不变。

所有Kubernetes中的资源，比如Pod,都通过一个叫URI的东西来区分，这个URI有一个UID,URI的重要组成部分是：对象的类型（比如pod），对象的名字，对象的命名空间，对于特殊的对象类型，在同一个命名空间内，所有的名字都是不同的，在对象只提供名称，不提供命名空间的情况下，这种情况是假定是默认的命名空间。UID是时间和空间上的唯一。

组件

k8s核心组件

etcd保存了整个集群的状态；

apiserver提供了资源操作的唯一入口，并提供认证、授权、访问控制、API注册和发现等机制；

controller manager负责维护集群的状态，比如故障检测、自动扩展、滚动更新等；

scheduler负责资源的调度，按照预定的调度策略将Pod调度到相应的机器上；

kubelet负责维护容器的生命周期，同时也负责Volume（CVI）和网络（CNI）的管理；

Container runtime负责镜像管理以及Pod和容器的真正运行（CRI）；

kube-proxy负责为Service提供cluster内部的服务发现和负载均衡；

kube-dns负责为整个集群提供DNS服务

Ingress Controller为服务提供外网入口

Heapster提供资源监控

Dashboard提供GUI

Federation提供跨可用区的集群

Fluentd-elasticsearch提供集群日志采集、存储与查询

k8s设计理念

I4CEQBAAEQ

核心层：Kubernetes最核心的功能，对外提供API构建高层的应用，对内提供插件式应用执行环境

应用层：部署（无状态应用、有状态应用、批处理任务、集群应用等）和路由（服务发现、DNS解析等）

管理层：系统度量（如基础设施、容器和网络的度量），自动化（如自动扩展、动态Provision等）以及策略管理（RBAC、Quota、PSP、NetworkPolicy等）

接口层：kubectl命令行工具、客户端SDK以及集群联邦

生态系统：在接口层之上的庞大容器集群管理调度的生态系统，可以划分为两个范畴

Kubernetes外部：日志、监控、配置管理、CI、CD、Workflow、FaaS、OTS应用、ChatOps等

Kubernetes内部：CRI、CNI、CVI、镜像仓库、Cloud Provider、集群自身的配置和管理等

kubernetes重要概念：

1.cluster

cluster是计算、存储和网络资源的集合，k8s利用这些资源运行各种基于容器的应用。

2.master

master是cluster的大脑，他的主要职责是调度，即决定将应用放在那里运行。master运行linux操作系统，可以是物理机或者虚拟机。为了实现高可用，可以运行多个master。

3.node

node的职责是运行容器应用。node由master管理，node负责监控并汇报容器的状态，同时根据master的要求管理容器的生命周期。node运行在linux的操作系统上，可以是物理机或者是虚拟机。

4.pod

pod是k8s的最小工作单元。每个pod包含一个或者多个容器。pod中的容器会作为一个整体被master调度到一个node上运行。

5.controller

k8s通常不会直接创建pod,而是通过controller来管理pod的。controller中定义了pod的部署特性，比如有几个剧本，在什么样的node上运行等。为了满足不同的业务场景，k8s提供了多种controller，包括deployment、replicaset、daemonset、statefulset、job等。

6.deployment

是最常用的controller。deployment可以管理pod的多个副本，并确保pod按照期望的状态运行。

7.replicaset

实现了pod的多副本管理。使用deployment时会自动创建replicaset，也就是说deployment是通过replicaset来管理pod的多个副本的，我们通常不需要直接使用replicaset。

8.daemonset

用于每个node最多只运行一个pod副本的场景。正如其名称所示的，daemonset通常用于运行daemon。

9.statefuleset

能够保证pod的每个副本在整个生命周期中名称是不变的，而其他controller不提供这个功能。当某个pod发生故障需要删除并重新启动时，pod的名称会发生变化，同时statefulset会保证副本按照固定的顺序启动、更新或者删除。

10.job

用于运行结束就删除的应用，而其他controller中的pod通常是长期持续运行的。

11.service

deployment可以部署多个副本，每个pod 都有自己的IP，外界如何访问这些副本那？

答案是service

k8s的 service定义了外界访问一组特定pod的方式。service有自己的IP和端口，service为pod提供了负载均衡。

k8s运行容器pod与访问容器这两项任务分别由controller和service执行。

12.namespace

可以将一个物理的cluster逻辑上划分成多个虚拟cluster，每个cluster就是一个namespace。不同的namespace里的资源是完全隔离的。

安装Kuberneters

yum安装

将以下列节点数与规格来进行部署 Kubernetes 集群，操作系统可采用Ubuntu 16.x与CentOS 7.x：

IP Address	Role	CPU	Memory
10.0.0.11	master1	1	2G
10.0.0.12	node1	1	2G
10.0.0.13	node2	1	2G

1.2 部署Kubernetes集群

1.2.1 主机环境说明

系统版本说明

[root@k8s-master ~]# cat /etc/redhat-release

CentOS Linux release 7.2.1511 (Core)

[root@k8s-master ~]# uname -r

3.10.0-327.el7.x86_64

[root@k8s-master ~]# getenforce

Disabled

[root@k8s-master ~]# systemctl status firewalld.service

● firewalld.service - firewalld - dynamic firewall daemon

Loaded: loaded (/usr/lib/systemd/system/firewalld.service; disabled; vendor preset: enabled)

Active: inactive (dead)

主机IP规划

主机名 IP 功能

k8s-master 10.0.0.11/172.16.1.11 Master

k8s-node-1 10.0.0.12/172.16.1.12 node1

k8s-node-2 10.0.0.13/172.16.1.13 node2

设置hosts解析

[root@k8s-master ~]# cat /etc/hosts

127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4

::1 localhost localhost.localdomain localhost6 localhost6.localdomain6

10.0.0.11 k8s-master

10.0.0.12 k8s-node-1

10.0.0.13 k8s-node-2

1.2.2 安装软件包

在三个节点上分别操作

[root@k8s-master ~]# yum install etcd docker kubernetes flannel -y

[root@k8s-node-1 ~]# yum install docker kubernetes flannel -y

[root@k8s-node-2 ~]# yum install docker kubernetes flannel -y

安装的软件版本说明

[root@k8s-master ~]# rpm -qa etcd docker kubernetes flannel

flannel-0.7.1-2.el7.x86_64

docker-1.12.6-71.git3e8e77d.el7.centos.1.x86_64

kubernetes-1.5.2-0.7.git269f928.el7.x86_64

etcd-3.2.11-1.el7.x86_64

1.2.3 修改配置etcd

yum安装的etcd默认配置文件在/etc/etcd/etcd.conf。

最终配置文件

[root@k8s-master ~]# grep -Ev '^$|#' /etc/etcd/etcd.conf

ETCD_DATA_DIR="/var/lib/etcd/default.etcd"

ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"

ETCD_NAME="default"

ETCD_ADVERTISE_CLIENT_URLS="http://10.0.0.11:2379"

启动etcd

[root@k8s-master ~]# systemctl enable etcd

[root@k8s-master ~]# systemctl start etcd

测试etcd

etcdctl set testdir/testkey0 0

[root@k8s-master ~]# etcdctl -C http://10.0.0.11:2379 cluster-health

member 8e9e05c52164694d is healthy: got healthy result from http://10.0.0.11:2379

cluster is healthy

1.2.4 配置并启动kubernetes

/etc/kubernetes/apiserver配置文件内容

[root@k8s-master ~]# grep -Ev '^$|#' /etc/kubernetes/apiserver

KUBE_API_ADDRESS="--insecure-bind-address=0.0.0.0"

KUBE_API_PORT="--port=8080"

KUBE_ETCD_SERVERS="--etcd-servers=http://10.0.0.11:2379"

KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.254.0.0/16"

KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"

KUBE_API_ARGS=""

*****记得注释掉ServiceAccount

解决方法：

1、$ vi /etc/kubernetes/apiserver

2、找到这一行 "KUBE_ADMISSION_CONTROL="--admission_control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota"，去掉ServiceAccount，保存退出。

3、重新启动kube-apiserver服务即可

此时执行kubectl get pods, no resources found问题得以解决

/etc/kubernetes/config配置文件

[root@k8s-master ~]# grep -Ev '^$|#' /etc/kubernetes/config

KUBE_LOGTOSTDERR="--logtostderr=true"

KUBE_LOG_LEVEL="--v=0"

KUBE_ALLOW_PRIV="--allow-privileged=false"

KUBE_MASTER="--master=http://10.0.0.11:8080"

启动服务

systemctl enable kube-apiserver.service

systemctl start kube-apiserver.service

systemctl enable kube-controller-manager.service

systemctl start kube-controller-manager.service

systemctl enable kube-scheduler.service

systemctl start kube-scheduler.service

1.2.5 部署配置node

node01

/etc/kubernetes/config配置文件

[root@k8s-node-1 ~]# grep -Ev '^$|#' /etc/kubernetes/config

KUBE_LOGTOSTDERR="--logtostderr=true"

KUBE_LOG_LEVEL="--v=0"

KUBE_ALLOW_PRIV="--allow-privileged=false"

KUBE_MASTER="--master=http://10.0.0.11:8080"

[root@k8s-node-1 ~]# grep -Ev '^$|#' /etc/kubernetes/kubelet

KUBELET_ADDRESS="--address=0.0.0.0"

KUBELET_HOSTNAME="--hostname-override=10.0.0.12"

KUBELET_API_SERVER="--api-servers=http://10.0.0.11:8080"

KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.access.redhat.com/rhel7/pod-infrastructure:latest"

KUBELET_ARGS=""

node012

/etc/kubernetes/config配置文件

[root@k8s-node-2 ~]# grep -Ev '^$|#' /etc/kubernetes/config

KUBE_LOGTOSTDERR="--logtostderr=true"

KUBE_LOG_LEVEL="--v=0"

KUBE_ALLOW_PRIV="--allow-privileged=false"

KUBE_MASTER="--master=http://10.0.0.11:8080"

[root@k8s-node-2 ~]# grep -Ev '^$|#' /etc/kubernetes/kubelet

KUBELET_ADDRESS="--address=0.0.0.0"

KUBELET_HOSTNAME="--hostname-override=10.0.0.13"

KUBELET_API_SERVER="--api-servers=http://10.0.0.11:8080"

KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.access.redhat.com/rhel7/pod-infrastructure:latest"

KUBELET_ARGS=""

启动

systemctl enable kubelet.service

systemctl start kubelet.service

systemctl enable kube-proxy.service

systemctl start kube-proxy.service

在master上查看集群中节点及节点状态

# kubectl -s http://10.0.0.11:8080 get node

[root@k8s-master ~]# kubectl -s http://10.0.0.11:8080 get node

NAME STATUS AGE

10.0.0.12 Ready 49s

10.0.0.13 Ready 56s

[root@k8s-master ~]# kubectl get nodes

NAME STATUS AGE

10.0.0.12 Ready 1m

10.0.0.13 Ready 1m

至此Kubernetes基础部署完成

安装遇到的坑

执行kubectl get pods READY 0/1

I4CEQBABSE

node节点手动pull镜像

方法一. yum安装

yum install *rhsm*

方法二（我是用这方法解决的）

执行命令：

① wget http://mirror.centos.org/centos/7/os/x86_64/Packages/python-rhsm-certificates-1.19.10-1.el7_4.x86_64.rpm

② rpm2cpio python-rhsm-certificates-1.19.10-1.el7_4.x86_64.rpm | cpio -iv --to-stdout ./etc/rhsm/ca/redhat-uep.pem | tee /etc/rhsm/ca/redhat-uep.pem

前两个命令会生成/etc/rhsm/ca/redhat-uep.pem文件.

③ docker pull registry.access.redhat.com/rhel7/pod-infrastructure:latest

kubeadm安装

1.准备三台虚拟机（rhel7.6）

主机名	ip	作用
master	10.0.0.11	master
node01	10.0.0.12	node1
node02	10.0.0.13	node2

第一步安装docker

yum install docker

第二步：配置k8syum源

cd /etc/yum.repos.d/

cat <<EOF> k8s.repo

[k8s]

name=k8s

enabled=1

gpgcheck=0

baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/

EOF

yum repolist

第三步：安装kubelet kubeadm kubectl

yum install kubelet-1.18.1 kubeadm-1.18.1 kubectl-1.18.1 -y

检查

rpm -qa kubelet kubeadm kubectl

#开机自启动

systemctl enable --now kubelet

kubeadm 创建 Cluster

1..主机名必须解析

要保证打开内置的桥功能，这个是借助于iptables来实现的

cat <<EOF > /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-ip6tables = 1

net.bridge.bridge-nf-call-iptables = 1

EOF

sysctl --system

#禁用swap

swapoff -a && sysctl -w vm.swappiness=0

master节点执行

初始化

kubeadm init --image-repository registry.aliyuncs.com/google_containers --kubernetes-version v1.18.1 --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address 10.0.0.11

其中字段含义：

--image-repository string：这个用于指定从什么位置来拉取镜像（1.13版本才有的），默认值是k8s.gcr.io，我们将其指定为国内镜像地址：registry.aliyuncs.com/google_containers，也可以先将镜像下载下来放到私有仓库直接从私有仓库拉取。

--kubernetes-version string：指定kubenets版本号，默认值是stable-1，会导致从https://dl.k8s.io/release/stable-1.txt下载最新的版本号，我们可以将其指定为固定版本（最新版：v1.18.1）来跳过网络请求。

--apiserver-advertise-address 指明用 Master 的哪个 interface 与 Cluster

的其他节点通信。如果 Master 有多个 interface，建议明确指定，如果不指定，kubeadm 会自动选择有默认网关的interface。

--pod-network-cidr指定 Pod 网络的范围。Kubernetes 支持多种网络方案，而且不同网络方案对 --pod-network-cidr有自己的要求，这里设置为10.244.0.0/16 是因为我们将使用 flannel 网络方案，必须设置成这个 CIDR。

配置kubectl

mkdir -p $HOME/.kube

cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

chown $(id -u):$(id -g) $HOME/.kube/config

echo "source <(kubectl completion bash)" >> ~/.bashrc

#验证kubectl

kubectl get cs

安装pod网络：flannel

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

systemctl restart kubelet

kubectl get nodes

kubectl get pods -n kube-system

添加node

master节点：

查看token：

kubeadm token list

node节点：

kubeadm join 10.0.0.11:6443 --token 3zs616.0pj9u5q0jyjsw7m4 \

--discovery-token-ca-cert-hash sha256:759c63113c25c6c7042c18476dc134914b5bc11945c3d2f17d51568af1827305

删除node

kubectl drain node01 --delete-local-data --force --ignore-daemonsets

kubectl delete node node01

删除后再添加：

systemctl stop kubelet

rm -rf /etc/kubernetes/*

kubeadm reset

kubeadm join 10.0.0.11:6443 --token 3zs616.0pj9u5q0jyjsw7m4 \

--discovery-token-ca-cert-hash sha256:759c63113c25c6c7042c18476dc134914b5bc11945c3d2f17d51568af1827305

获取ca证书sha256编码hash值

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'

systemctl restart kubelet.service

kubernetes Pod管理

Pod命令

创建一个pod

kubectl run nginx --image=nginx

pod/nginx created

查看所有 pod 列表,

-n 后跟 namespace, 查看指定的命名空间 -o wide 查看详细信息

kubectl get pod

kubectl get pod -n kube

kubectl get pod -o wide

查看 RC 和 service 列表

-o wide 查看详细信息

kubectl get rc,svc

kubectl get pod,svc -o wide

kubectl get pod <pod-name> -o yaml

显示 Node 的详细信息

kubectl describe node server2

显示 Pod 的详细信息, 特别是查看 pod 无法创建的时候的日志

kubectl describe pod <pod-name>

eg:

kubectl describe pod nginx

根据 yaml 创建资源, apply 可以重复执行，create 不行

kubectl create -f pod.yaml

kubectl apply -f pod.yaml

基于 pod.yaml 定义的名称删除 pod

kubectl delete -f pod.yaml

删除所有包含某个 label 的pod 和 service

kubectl delete pod,svc -l name=<label-name>

删除所有 Pod

kubectl delete pod --all

查看 endpoint 列表

kubectl get endpoints

执行 pod 的命令

kubectl exec <pod-name> -- date

kubectl exec <pod-name> -- bash

kubectl exec <pod-name> -- ping 172.25.63.1

通过bash获得 pod 中某个容器的TTY，相当于登录容器

kubectl exec -it <pod-name> -c <container-name> -- bash

eg:

kubectl exec -it nginx -- bash

查看容器的日志

kubectl logs <pod-name>

kubectl logs -f <pod-name> # 实时查看日志

kubectl log <pod-name> -c <container_name> # 若 pod 只有一个容器，可以不加 -c

查看资源清单注释

kubectl explain pod

kubectl explain pod.apiVersion

查看节点 labels

kubectl get node --show-labels

Pod操作

创建pod

默认创建pod时使用自主式的pod管理器，这种自主创建的pod再删除时会直接删除

kubectl run nginx --image=nginx

指定pod管理器deployment来创建pod，这种管理器在pod删除时会帮我们自动启动：

kubectl create deployment myapp --image=ikubernetes/myapp:v1

pod拉伸

kubectl scale --replicas=2 deployment myapp

集群内部pod外部访问

kubectl expose deployment myapp01 --port=80 --target-port=80

kubectl describe svc myapp01

集群外部访问pod

当然也可以在创建service时加--type=NodePort指定类型。

kubectl edit svc myapp01

I4CEQBAAP4

pod版本更新

更新版本

kubectl set image deployments myapp01 nginx=nginx:v2 --record

查看更新

kubectl rollout history deployment myapp01

回滚

kubectl rollout undo deployment myapp --to-revision=1

Pod资源清单

资源清单中的属性

查看属性的用法：

kubectl explain pod.spec

必须存在的属性：

apiVersion(String):k8s api的版本，目前基本是V1，可以使用kubectl api-versions命令查询

kind(String):yaml文件定义的资源类型和角色，，比如Pod

metadata(Object):元数据对象，固定值就写metadata

metadata.name(String):元数据对象的名字，由我们编写，如定义Pod的名字

metadata.namespace:元数据对象的命名空间，由我们自身定义

Spec(Object):详细定义对象，固定值就写Spec

spec.containers:Spec对象的容器列表定义，是个列表

spec.containers[].name(String):定义容器的名字

spec.containers[].image(String):容器用到的镜像名称

主要的属性：

spec.containers[].name(String):容器的名称

spec.containers[].imagePullPolicy(String):定义镜像拉取策略，有Always（每次都尝试重新拉取镜像）、Never（仅使用本地镜像）、IfNotPresent（如果本地有镜像就使用本地镜像，没有则拉取镜像）三个值可选，默认是Always

spec.containers[].command:指定容器启动命令，因为是数组可以指定多个，不指定则使用镜像打包时使用的启动命令

spec.containers[].args:指定容器启动命令参数，因为是数组可以指定多个

spec.containers[].workingDir(String):指定容器的工作目录

spec.containers[].volumeMounts:指定容器内部的存储卷配置

spec.containers[].volumeMounts[].name(String):指定被容器挂载的存储卷的名称

spec.containers[].volumeMounts[].mountPath(String):指定被容器挂载的存储卷的路径

spec.containers[].volumeMounts[].readOnly(String):设置存储卷路径的读写模式，true或者false，默认为读写模式

spec.containers[].ports:指定容器需要用到的端口列表

spec.containers[].ports[].name(String):指定端口名称

spec.containers[].ports[].containerPort(String):指定容器需要监听的端口号

spec.containers[].ports[].hostPort(String):指定容器所在主机需要监听的端口号，默认跟containerPort相同，注意设置了hostPort，同一台主机无法启动该容器的相同副本（因为主机的端口号不能相同，会冲突）

spec.containers[].ports[].protocol(String):指定端口协议，支持TCP和UDP,默认值是TCP

spec.containers[].env:指定容器运行前需要设置的环境变量列表

spec.containers[].env[].name(String):指定环境变量名称

spec.containers[].env[].value(String):指定环境变量值

spec.containers[].resources(Object):指定资源限制和资源请求的值

spec.containers[].resources.limits(Object):指定设置容器运行时资源的运行上限

spec.containers[].resources.limits.cpu(String):指定cpu的限制，单位为core数，将用于docker run --cpu-shares参数

spec.containers[].resources.limits.memory(String):指定mem内存的限制

spec.containers[].resources.requests(Object):指定容器启动和调度时的限制设置

spec.containers[].resources.requests.cpu(String):cpu请求，单位为core数，容器启动时初始化可用数量

spec.containers[].resources.requests.memory(String):内存请求，容器启动的初始化可用数量

额外属性

spec.restartPolicy(String):定义Pod的重启策略，可选值为Always(Pod一旦终止运行，则无论容器是如何终止的，kubelet服务都将重启它)、OnFailure(只有Pod以非零码终止时，kubelet才会重启该容器，如果是正常结束，退出码为0，则kubelet将不会重启它)、Never(Pod终止后，kubelet将退出码报告给master，不会重启该Pod)

spec.nodeSelector(Object):定义Node的Label过滤标签，以key:value格式指定

spec.imagePullSecrets(Object):定义pull镜像时使用secret名称，以name:secretkey格式指定

spec.hostNetwork(Boolean):定义是否使用主机网络模式，默认值为false，设置true表示使用宿主机网络，不使用docker网桥，同时设置了true将无法在同一台宿主机上启动第二个副本

Pod生命周期

Pod的phase

挂起Pending：Pod已经被Kubernetes系统接受，但是有一个或多个容器镜像尚未创建，等待时间包括调度Pod的时间和通过网络下载镜像的时间。

运行中Running：该Pod已经绑定到一个节点上，Pod中所有的容器都已经被创建，至少有一个容器正在运行或者处于启动或者重启状态。

成功Succeeded：Pod中的所有容器都被成功终止，并且不会在重启。

失败Failed：Pod中的所有容器已经终止，并且至少有一个容器是因为失败终止，也就是说，容器以非0状态退出或者被系统终止。

未知Unknown：因为某些议无法获取Pod的状态，哦那个厂是因为与Pod所在的节点通信失败。

init容器

Init容器的作用：

Init 容器可以包含一些安装过程中应用容器中不存在的实用工具或个性化代码。

Init 容器可以安全地运行这些工具，避免这些工具导致应用镜像的安全性降低。

应用镜像的创建者和部署者可以各自独立工作，而没有必要联合构建一个单独的应用镜像。

Init 容器能以不同于Pod内应用容器的文件系统视图运行。因此，Init容器可具有访问 Secrets 的权限，而应用容器不能够访问。

由于 Init 容器必须在应用容器启动之前运行完成，因此 Init

容器提供了一种机制来阻塞或延迟应用容器的启动，直到满足了一组先决条件。一旦前置条件满足，Pod内的所有的应用容器会并行启动。

[root@server1 manifest]# cat init.yaml

apiVersion: v1

kind: Pod

metadata:

labels:

app: myapp

spec:

containers:

- name: myapp-container

image: myapp:v1

initContainers:

- name: init-container

image: busybox

command: ["/bin/sh", "-c", "until nslookup myservice.default.svc.cluster.local; do echo waiting for myservice; sleep 2; done"]

容器探针

探针是由 kubelet 对容器执⾏的定期诊断。要执⾏诊断， kubelet 调⽤由容器实现的 Handler。有三种类型的探测方式：

ExecAction：在容器内执⾏指定命令。如果命令退出时返回码为 0 则认为诊断成功。

TCPSocketAction：对指定端⼝上的容器的 IP 地址进⾏ TCP 检查。如果端⼝打开，则诊断被认为是成功的

HTTPGetAction：对指定的端⼝和路径上的容器的 IP 地址执⾏ HTTP Get 请求。如果响应的状态码⼤于等于200且⼩于400，则诊断被认为是成功的。

Kubelet 可以选择是否执行在容器上运行的两种探针执行和做出反应：

livenessProbe：指示容器是否正在运行。如果存活探测失败，则 kubelet 会杀死容器，并且容器将受到其重启策略的影响。如果容器不提供存活探针，则默认状态为 Success。

readinessProbe：指示容器是否准备好服务请求。如果就绪探测失败，端点控制器将从与 Pod 匹配的所有 Service 的端点中删除该 Pod 的 IP 地址。初始延迟之前的就绪状态默认为 Failure。如果容器不提供就绪探针，则默认状态为 Success。

startupProbe: 指示容器中的应用是否已经启动。如果提供了启动探测(startup probe)，则禁用所有其他探测，直到它成功为止。如果启动探测失败，kubelet 将杀死容器，容器服从其重启策略进行重启。如果容器没有提供启动探测，则默认状态为成功Success

————————————————

livenessProbe存活探测示例:

[root@server1 manifest]# cat liveness.yaml

apiVersion: v1

kind: Pod

metadata:

spec:

containers:

- name: myapp

image: ikubernetes/myapp:v1

imagePullPolicy: IfNotPresent

livenessProbe:

tcpSocket:

port: 8080

initialDelaySeconds: 1

periodSeconds: 3

timeoutSeconds: 1

initialDelaySeconds: 1表示pod运行1s后检测状态。

periodSeconds: 3表示每3s检测一次。

timeoutSeconds: 1表示检测1s后即超时进行下次检测

readinessProbe就绪检测示例：

[root@server1 manifest]# vim reainess.yaml

[root@server1 manifest]# cat reainess.yaml

apiVersion: v1

kind: Pod

metadata:

spec:

containers:

- name: readiness

image: nginx

readinessProbe:

httpGet:

path: /test.html

port: 80

initialDelaySeconds: 1

periodSeconds: 3

timeoutSeconds: 1

Pod控制器

Replication Controller和ReplicaSet
Deployment
DaemonSet
StatefulSet
Job
CronJob
HPA全称Horizontal Pod Autoscaler

ReplicaSet

Deployment

apiVersion: apps/v1 #Api接口版本
kind: Deployment #定义控制器
metadata:
name: nginx-deployment #deployment名称
spec:
replicas: 3 #在具体参数信息spec下，只指定了副本数量，还需要指定副本标签与 Deployment控制器进行匹配
selector:
matchLabels:
app: nginx-deployment
template:
metadata:
labels:
app: nginx-deployment
spec:
containers:
- name: nginx-deployment
image: nginx:v2
ports:
- containerPort: 80

DaemonSet

kubernetes Service

Service可以看作是一组提供相同服务的Pod对外的访问接口。借助Service，应用可以方便地实现服务发现和负载均衡。

service默认只支持4层负载均衡能力，没有7层功能。（可以通过Ingress实现）

service的类型

ClusterIP：默认值，k8s系统给service自动分配的虚拟IP，只能在集群内部访问。

NodePort：将Service通过指定的Node上的端口暴露给外部，访问任意一个NodeIP:nodePort都将路由到ClusterIP。

LoadBalancer：在 NodePort 的基础上，借助 cloud provider 创建一个外部的负载均衡器，并将请求转发到 :NodePort，此模式只能在云服务器上使用。

ExternalName：将服务通过 DNS CNAME 记录方式转发到指定的域名（通过 spec.externlName 设定）。

Ingress

kubernetes 存储

Configmap

Configmap用于保存配置数据，以键值对的形式存储

Configmap资源提供了向Pod诸如配置数据的方法

旨在让镜像和配置文件解偶，以便实现镜像的可移植性和可复用性

创建configmap

1.通过key、valuec创建

kubectl create configmap cm1 --from-literal=key1=value1

kubectl get cm

kubectl describe cm cm1

输出为yml格式查看：

kubectl get cm cm1 -o yaml

2.通过文件创建

kubectl create configmap cm2 --from-file=/etc/resolv.conf

3.通过目录创建

kubectl create configmap cm3 --from-file=/root/cm

4.通过yml创建

apiVersion: v1
kind: ConfigMap
metadata:
name: cm4
data:
db_host: "172.25.63.250"
db_port: "3306"

使用configmap

pv与pvc

apiVersion: v1
kind: PersistentVolume
metadata:
name: pv1
spec:
capacity:
storage: 500Mi #设置pv大小
volumeMode: Filesystem #卷类型
accessModes:
- ReadWriteOnce #访问模式
persistentVolumeReclaimPolicy: Recycle #回收策略
storageClassName: nfs #存储类别名称
nfs:
server: 192.168.0.6 #设置nfs挂载路径和服务器地址
path: /root/nginx

pvc

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: pvc1
spec:
storageClassName: nfs
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 500Mi

创建pod使用pvc

apiVersion: v1
kind: Pod
metadata:
name: testpd
spec:
containers:
- image: nginx:v1
name: test-container
volumeMounts:
- mountPath: /usr/share/nginx/html
name: storage1
volumes:
- name: storage1
nfs:
persistentVolumeClaim:
claimName: pvc1

posted @ 2023-08-30 13:37 jinqiu001 阅读(31) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· python-学习

· rsync

· 2小时快速掌握kubernetes常用对象和关键组件

· kubernetes详述-k8s安装与使用

· kubernetes基础知识笔记--All In One

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了

公告

昵称： jinqiu001
园龄： 6年3个月
粉丝： 2
关注： 14

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

阅读排行榜

评论排行榜

1. Pycharm 2022.2激活码到2024年12月，亲测有效(5)

-----一入此门深似海,从此红尘是路人

docker

容器

linux容器(lxc)

docker容器

docker的安装

docker的使用

docker的容器管理

docker容器管理

docker容器的网络访问

docker的数据卷管理

docker容器保存为镜像

docker 里面启动服务报错

dockerfile自动构建docker镜像

docker registry

docker-compose(单机版的容器编排工具)

Dcoker跨主机通信之overlay

docker企业级镜像仓库harbor

k8s

Kubernetes 概述

简介

组件

k8s设计理念

kubernetes重要概念：

安装Kuberneters

yum安装

安装遇到的坑

kubeadm安装

第一步安装docker

第二步：配置k8syum源

第三步：安装kubelet kubeadm kubectl

kubeadm 创建 Cluster

配置kubectl

安装pod网络：flannel

添加node

删除node

删除后再添加：

获取ca证书sha256编码hash值

kubernetes Pod管理

Pod命令

创建一个pod

查看所有 pod 列表,

查看 RC 和 service 列表

显示 Node 的详细信息

显示 Pod 的详细信息, 特别是查看 pod 无法创建的时候的日志

根据 yaml 创建资源, apply 可以重复执行，create 不行

基于 pod.yaml 定义的名称删除 pod

删除所有包含某个 label 的pod 和 service

删除所有 Pod

查看 endpoint 列表

执行 pod 的命令

通过bash获得 pod 中某个容器的TTY，相当于登录容器

查看容器的日志

查看资源清单注释

查看节点 labels

Pod操作

创建pod

pod拉伸

集群内部pod外部访问

集群外部访问pod

pod版本更新

Pod资源清单

资源清单中的属性

Pod生命周期

Pod的phase

init容器

容器探针

Pod控制器

ReplicaSet

Deployment

DaemonSet

kubernetes Service

service的类型

Ingress

kubernetes 存储

Configmap

创建configmap

1.通过key、valuec创建

2.通过文件创建

3.通过目录创建