Kubectl 常用命令

命令的语法

kubectl [command] [TYPE] [NAME] [flags]
# comand：指定要对资源执行的操作，例如 create、get、describe 和delete
# TYPE：指定资源类型，资源类型是大小写敏感的，开发者能够以单数、复数和缩略的形式。
# NAME：指定资源的名称，名称也大小写敏感的。如果省略名称，则会显示所有的资源
# flags：指定可选的参数。例如，可用-s 或者–server 参数指定Kubernetes API server 的地址和端口

基础命令

命令名	说明
kubectl	前缀
create	通过文件名或标准输入创建资源
expose	将一个资源公开为一个新的Service
run	创建并运行一个或多个容器镜像
set	配置资源对象设置特定功能
get	获取一个或多个资源对象的信息
explain	查看资源对象的详细信息(文档参考资料)
edit	使用默认编辑器编辑服务器上定义的资源对象
delete	通过文件名、标准输入、资源名称或标签选择器来删除资源

部署和集群管理命令

命令名	部署命令说明
kubectl	前缀
rollout	资源管理对象的部署
rollout-update	对给定的复制控制器滚动更新
scale	扩容或者缩容deployment replicaset replication contrller等
autoscale	自动设置在k8s系统中运行的pod数量（水平自动伸缩）

命令名	集群管理命令说明
kubectl	前缀
cetificate	修改证书资源资源
cluster-info	查看集群信息
top	显示资源 cpu 内存 存储使用情况,需要Heapster运行
cordon	标记节点为不可调度
uncordon	指定节点为可调度
drain	安全的驱逐节点的所有pod
taint	修改节点taint标记

故障排查和调试命令

命令名	说明
kubectl	前缀
describe	显示一个或多个资源对象的详细信息
logs	输出pod资源对象中一个容器的日志
attach	附加到一个运行的容器
exec	在指定容器内执行命令
port-forward	转发一个或多个本地端口到一个pod
proxy	将本机指定端口映射到kube-apiserver
cp	用于pod与主机交换文件
auth	检查授权

高级命令

命令名	说明
kubectl	前缀
diff	对比本地json/yaml文件与kube-apiserver中运行的配置文件是否有差异
apply	通过json/yaml文件 标准输入对资源进行配置更新或者创建
patch	通过patch方式修改资源对象字段（补丁式）
replace	通过json/yaml文件或者标准输入来替换资源对象
wait	在一个或者多个资源上等待条件达成
convert	转换json/yaml文件为不同的资源版本
kustomize	定制kubernetes配置

设置命令

命令名	说明
kubectl	前缀
label	更新资源的标签
annotate	更新一个或者多个资源对象的注释（annotaion）信息
completion	实现Kubectl工具自动补全

其他命令

命令名	说明
kubectl	前缀
config	管理kubeconfig配置文件
plugin	运行命令行插件功能
version	查看客户端服务端的系统版本信息
api-versions	列出当前kubernetes系统支持的资源组和资源版本表现形式为/
api-resources	列出当前kubernetes系统支持的resource资源列表
options	查看支持的参数列表

YAML文件

YAML 介绍

1. YAML ：仍是一种标记语言。为了强调这种语言以数据做为中心，而不是以标记语言为重点。
2. YAML 是一个可读性高，用来表达数据序列的格式。
3. 又叫资源清单文件或资源编排

YAML 基本语法

• 使用空格做为缩进
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• 低版本缩进时不允许使用 Tab 键，只允许使用空格
• 使用#标识注释，从这个字符一直到行尾，都会被解释器忽略
• 字符后面缩进一个空格,如 冒号,逗号等后面
• 使用- - -表示新的yaml文件开始

YAML 组成部分

1. 控制器定义
2. 被控制对象

常用字段说明(K8s中yaml文件说明)

名字	说明
apiVersion	API版本
kind	资源类型
metadata	资源元数据(Pod元数据)
spec	资源规格(Pod规格)
replicas	副本数量
selector	标签选择器
template	Pod模板
containers	容器配置

快速编写YAML文件

• 使用 kubectl create 命令生成yaml文件

# -o yaml 表示不创建资源,只生成yaml
# --dry-run 表示尝试运行,并不会真正执行
kubectl create deployment haha --image=nginx -o yaml --dry-run

这只是一个输出,没有生成yaml文件

# 实际生成yaml文件
kubectl create deployment haha --image=nginx -o yaml --dry-run > test1.yaml

• 使用 kubectl get 命令导出yaml文件

# deploy 表示类型
# 这里之所以有nginx是上面生成的
kubectl get deploy
kubectl get deploy nginx -o=yaml --export > test2.yaml

YAML 支持的数据结构

• 对象

name: haha
age: 18
# 或
hash: { name: haha, age: 18 }

• 数组

people
- zhangsan
- lisi
# 或者
people: [zhangsan, lisi]

• 纯量（scalars）
  单个的、不可再分的值

# 数值
num: 12
# 布尔
isTrue: true
# null,~表示null
isNull: ~
# 时间
time: 2022-09-14t17:32:15.10-05:00
# 日期
date: 2022-09-14
# 强转 双感叹号表示强制转换数据类型
e: !!str 123
f: !!str true
# 字符串
str: 这是字符串
str: 这是'name: zhangsan' 包含空格或特殊字符需引号
str: 'sss\nsss'
str: "sss\nsss"
str:'zhang''san' # 单引号之间使用单引号许连续2个
str: sss |
asd >
asd
# 表示换行

Pod

Pod基本概念

• 最小部署的单元
• 包含多个容器（一组容器的集合）
• 一个pod中容器共享网络命名空间
• pod是短暂的（如重启后ip改变了）

Pod存在意义

• Pod是多几次设计，运行多个应用程序
• 为了亲密性应用，如：两个应用之间进行交互，网络之间调用两个应用需要频繁调用

Pod实现机制

• 共享网络

  1. 容器本身之间互相隔离的，如使用：namespace或group
  2. 要共享网络的前提条件是容器都在同一个namespace里或同一个group里
  3. 通过Pause容器,把其他业务容器加入到Pause容器里面,让所有业务容器都在一个名称空间中,可以实现网络共享

• 共享存储
  引入数据卷概念Volumn,使用数据卷进行数据持久化存储

镜像拉取

	说明
imagePullPolicy: IfNotPresent	默认值,当镜像在宿主机上不存在时才拉取
imagePullPolicy: Always	每次创建Pod都会重新拉取一次镜像
imagePullPolicy: Never	Pod永远不会主动拉取这个镜像

资源调度

	说明
spec.containers[].resource	前缀
.limits.cpu	cpu最大核数(1核==1000M)
.limits.memor	内存最大
.requests.cpu	调度 cpu 核数
.requests.cpu	调度 内存数

重启策略

	说明
restartPolicy: Always	当容器终止退出后,总是重启容器,默认策略
restartPolicy: OnFailure	当容器异常退出(状态码非0)时,才重启容器
restartPolicy: Never	当容器终止退出,从不重启容器

健康检查

• 容器检查
  但是容器检查如果容器出来问题,那么检查不出来,如当java程序出现堆内存溢出时,程序是已经不能提供服务了,容器还是运行状态,但检查不出来
• 应用层面健康检查
  如: 进行调用,看能否返回

LivenessProbe(存活检查): 如果检查失败,将杀死容器,根据Pod的restartPolicy来操作
readinessProbe(就绪检查): 如果检查失败,Kubernetes会把Pod从service endpoints中剔除

Probe支持三种检查方法:
1. httpGet 发送HTTP请求,返回200-400范围状态码为成功
2. exec 执行Shell命令返回状态码为0是成功
3. tcpSocket 发起TCP Socket 建立成功

Pod创建流程

在master节点上
create pod ------> apiserver ------> etcd(存储)
scheduler ------> apiserver ------> etcd(获取)------>调度算法------> node节点
kubelet ------> apiserver ------> 读取etcd拿到分配给当前节点的Pod ------> docker创建容器(或其他容器工具创建容器,因为1.2以后不支持docker)

影响Pod调度

1. Pod资源限制对Pod调用产生影响
2. 节点选择器标签影响

# 节点选择器指定环境
kubectl label node slave1 env_role=dev 
# node---> 指node节点 
# slave1 --->指选择那个宿主机
# dev ---> 环境 

# 查看
kubectl get nodes slave1 --show-labels

Pod节点亲和性

• 硬亲和性

  1. 约束条件必须满足
  2. 如满足则调度,不满足则不调度

• 软亲和性

  1. 尝试满足,不是保证

• 反亲和性

• 支持常用操作符
  In NotIn Exists Gt Lt DoesNotExists

Pod污点和污点容忍

• 基本介绍
  1. nodeSelector和nodeAffinity : Pod调度到某些节点上,是Pod属性,调度时实现
  2. Taint 污点: 节点不做普通分配调度,是节点属性
• 场景
  1. 专用节点
  2. 配置特定硬件节点
  3. 基于Taint驱逐
• 案例
  1. 查看节点污点情况

  kubectl describe node master | grep Taint
  

  2. 污点值
      NoSchedule:一定不被调度
      PreferNoSchdule:尽量不被调度
      NoExecute:不会调度，并且还会驱逐Node已有Pod
  3. 为节点创建污点

  # env_role ---> key名字
  # yes ---> value 值
  # NoSchedule ---> 污点值 
  kubectl taint node slave1 env_role=yes:NoSchedule
  # 效果就是现在镜像不会调度到slave1节点上了
  

  4. 删除污点

  kubectl taint node slave1 env_role:NoSchedule-
  

• 污点容忍

# 在yaml文件中加上
spec:
	tolerations:
		-key: "设置污点时的key名称"
		operator: "Equal"
		value: "设置污点时的value值"
		effect: "NoSchedule"

YAML文件定义Pod

apiVersion: v1
kind: Pod
metadata: //元数据
	name: string
	namespace: string
	labels:
		-name: string
	annotations:
		-name: string
spec:
	containers: //pod 中的容器列表，可以有多个容器
		- name: string //容器的名称
	image: string //容器中的镜像
	imagesPullPolicy: [Always|Never|IfNotPresent]//获取镜像的策略，默认值为Always，每次都尝试重新下载镜像
	command: [string] //容器的启动命令列表（不配置的话使用镜像内部的命令）args:[string] //启动参数列表
	workingDir: string //容器的工作目录 volumeMounts: //挂载到到容器内部的存储卷设置
		-name: string
	mountPath: string //存储卷在容器内部 Mount 的绝对路径 readOnly: boolean //默认值为读写
	ports: //容器需要暴露的端口号列表
		-name: string
	containerPort: int //容器要暴露的端口
	hostPort: int //容器所在主机监听的端口（容器暴露端口映射到宿主机的端口，设置hostPort 时同一 台宿主机将不能再启动该容器的第 2 份副本）
	protocol: string //TCP 和 UDP，默认值为 TCP env: //容器运行前要设置的环境列表
		-name: string value: string
resources:
	limits: //资源限制，容器的最大可用资源数量 cpu: Srting
		memory: string
		requeste: //资源限制，容器启动的初始可用资源数量 cpu: string
		memory: string
		livenessProbe: //pod 内容器健康检查的设置 exec:
			command: [string] //exec 方式需要指定的命令或脚本 httpGet: //通过httpget 检查健康
		path: string port: number host: string scheme: Srtring httpHeaders:
			- name: Stirng value: string
		tcpSocket: //通过 tcpSocket 检查健康
			port: number initialDelaySeconds: 0//首次检查时间 timeoutSeconds: 0 //检查超时时间
			periodSeconds: 0 //检查间隔时间
			successThreshold: 0
			failureThreshold: 0 securityContext: //安全配置
			privileged: falae
		restartPolicy: [Always|Never|OnFailure]//重启策略，默认值为Always
		nodeSelector: object //节点选择，表示将该 Pod 调度到包含这些label 的Node 上，以key:value 格式指定
imagePullSecrets:
	-name: string
	hostNetwork: false //是否使用主机网络模式，弃用 Docker 网桥，默认否volumes: //在该 pod 上定义共享存储卷列表
		-name: string emptyDir: {} hostPath:
	path: string secret:
	secretName: string item:
		-key: string path: string
	configMap: name: string items:
		-key: string
	path: string

Controller

Controller介绍

• 在集群上管理和运行容器的对象

Pod和Controller关系

• Pod是通过Controller实现应用的运维，比如伸缩，滚动升级等
• Pod和Controller之间通过label和selector标签建立关系

Deployment控制器应用场景

• 部署无状态应用
• 管理Pod和ReplicaSet
• 部署滚动、升级等功能
• web服务、微服务

Deployment控制器部署应用

# 生成yaml文件
kubectl create deployment web --image=nginx --dry-run -o yaml > web.yaml
# 通过yaml 部署应用
kubectl apply -f web.yaml
# 对外暴露端口生成yaml文件
kubectl expose deployment web --port=80 --type=NodePort --target-port=80 --name=web1 -o yaml >web1.yaml 
# 部署
kubectl apply -f web1.yaml
# 查看
kubectl get pod,svc

升级回滚

升级

vim /opt/soft/web.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: web
  name: web
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: web
    spec:
      containers:
      - image: nginx:1.14 #指定版本
        name: nginx
        resources: {}
status: {}

# 在node节点上通过docker来查看
docker images

# 升级到1.15
kubectl set image deployment web nginx=nginx:1.15

流程介绍：
  先下载1.15，在下载的过程1.14还是在运行的，当下载完就替换

查看升级状态

kubectl rollout status deployment web

回滚

# 查看历史版本
kubectl rollout history deployment web

# 还原到上一个状态
kubectl rollout undo deployment web

# 回滚到指定版本
kubectl rollout undo deployment web --to-revision=2

弹性伸缩

# 应用场景： 当多人访问时，可以创建副本来进行
# 创建10个副本
kubectl scale deployment web --replicas=10

有状态部署

无状态和有状态区别

无状态

1. 认为Pod都是一样的
2. 没有顺序要求
3. 不用考虑在那个node运行
4. 随意进行伸缩和扩展

有状态

1. 上面所有因素都要考虑到
2. 让每个Pod独立,保持Pod启动顺序和唯一性
3. 唯一的网络标识符,持久存储
4. 有序,如mysql主从

部署有状态应用

无头service

1. ClusterIP: none

开始部署

1. SatefulSet 部署

vim service2.yaml

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  ports:
    - port: 80
      name: web
  clusterIP: None  # 定义无头ip
  selector:
    app: nginx
---

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: nginx-statefulset # 定义名称
  namespace: default
spec:
  serviceName: nginx
  replicas: 3 # 定义创建副本数
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
 		  image: nginx:latest
          ports:
            - containerPort: 80

kubectl apply -f service2.yaml

2. deployment和statefulset区别

有唯一标识
根据主机名+按照一定规则生成域名
每个pod有唯一主机名
唯一域名: 主机名.service名称.名称空间.svc.cluster.local
如: nginx-sataefulset-0.nginx.default.svc.cluster.local
# nginx-sataefulset-0 主机名
# nginx service名称
# default 名称空间

部署守护进程DaemonSet

说明

这个 Pod 运行在  k8s 集群里的每一个节点（Node）上；
每个节点上只会运行一个这样的 Pod 实例；
如果新的节点加入 k8s 集群后，该 Pod 会自动地在新节点上被创建出来；
而当旧节点被删除后，它上面的 Pod 也相应地会被回收掉
如: 在每个节点安装数据采集工具

部署

vim service3.yaml

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ds-test
  labels:
    app: filebeat
spec:
  selector:
    matchLabels:
      app: filebeat
  template:
    metadata:
      labels:
        app: filebeat
    spec:
      containers:
        - name: logs
          image: nginx
          ports:
            - containerPort: 80
          volumeMounts:
            - name: varlog 
              mountPath: /tmp/log  # 数据采集日志保留的目录
      volumes: 
        - name: varlog
          hostPath:
            path: /var/log  # 容器数据卷

kubectl apply -f service3.yaml
# ds-test-mzx4v pod名字
kubectl exec -it ds-test-mzx4v bash
ls /opt/temp/log

job和cronjob(一次性任务和定时任务)

Job

apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  template:
    spec:
      containers:
        - name: pi
          image: perl # 计算圆周率
          command: ["perl", "-Mbignum=bpi", "-wle", "pring bpi(2000)"]
      restartPolicy: Never
  backoffLimit: 4 # 重启策略,默认6

已经计算完成

 kubectl get job
 # pi-hhb7 pod名称
 kubectl logs pi-hhb7

cronjob

# 每隔一分钟输出一次
apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: hello
              image: busybox
              args:
                - /bin/sh
                - -c
                - date; echo hello from the k8s
          restartPolicy: OnFailure 

kubectl get cronjob
kubectl logs hello-1663299480-bp4mw

Service

Service存在的意义

1. 防止Pod失联（服务发现）
2. 定义一组Pod的访问策略（负载均衡）

Pod和Service关系

• 根据label和selector标签建立关联
• Service是有IP的，叫vip 就是虚拟ip，是先经过vip才能到pod的ip

常用Service类型

1. ClusterIp：集群内部使用
2. NodePort：对外访问应用使用
3. LoadBalancer：对外访问应用使用，公有云

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    app: web
  name: web
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: web
  type: ClusterIP # 设置类型
status:
  loadBalancer: {}

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    app: web
  name: web1 # 设置名称
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: web
  type: NodePort # 设置类型
status:
  loadBalancer: {}

node内网部署应用外网是不能访问的

• 找到一台可以进行外网访问机器，安装nginx，反向代理，手动添加可以访问节点到nginx
• LoadBalancer： 连接到公有云时使用了负载均衡做到

Secret

作用

1. 加密数据存在etcd里面,让Pod容器以挂载Volume方式进行访问
2. 场景: 凭证

创建配置文件

echo -n 'admin' | base64
echo -n '123456' | base64

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  username: YWRtaW4= # base64编码
  password: MTIzNDU2

kubectl get sercret

挂载

以变量形式进行挂载

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: nginx
      image: nginx
      env:
        - name: SECRET_USERNAME
          valueFrom:
            secretKeyRef:
              name: mysecret
              key: username
        - name: SECRET_PASSWORD
          valueFrom:
            secreKeyRef:
              name: mysecret
              key: password

kubectl apply -f secret-val.yaml
kubectl  exec -it mypod bash

echo $SECRET_USERNAME
echo $SECRET_PASSWORD

以Volume形式挂载

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: nginx
      image: nginx
      volumeMounts:
        - name: foo
          mountPath: "/etc/foo" # 挂载位置
          readOnly: true
  volumes:
    - name: foo
      secret:
        secretName: mysecret # 挂载名字

kubectl exec -it mypod bash
ls /etc/foo

ConfigMap

作用

1. 不加密数据存在etcd里面,让Pod容器以挂载Volume方式进行访问
2. 场景: 配置文件

创建配置文件

vim redis.properties

redis.host=127.0.0.1
redis.port=6379

# 创建 configmap  
kubectl create configmap redis-config --from-file=redis.properties

# 查看 cm ---> configmap简称
kubectl get cm
# 查看文件信息
kubectl describe cm redis-config

挂载

以volume形式挂载

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: ["/bin/sh", "-c", "cat /opt/soft/yaml/redis.properties"] # 存放redis.properties的目录
      volumeMounts:
        - name: config-volume
          mountPath: /opt/soft/yaml  # 存放redis.properties的目录
  volumes:
    - name: config-volume
      configMap:
        name: redis-config #要跟configmap名称一样
  restartPolicy: Never

kubectl apply -f cm.yaml
kubectl logs mypod

以变量形式进行挂载

vim config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfig
  namespace: default
data:
  special.level: info
  special.type: hello


kubectl apply -f config.yaml 

vim config-var.yaml

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: busybox
      image: busybox
      command: ["/bin/sh", "-c", "echo ${LEVEL} ${TYPE}"]
      env:
        - name: LEVEL
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.level
        - name: TYPE
          valueFrom:
            configMapKeyRef:
              name: myconfig
              key: special.type
  restartPolicy: Never

kubectl apply -f config-var.yaml
kubectl logs mypod

集群安全机制

概述

• 访问k8s集群时候,需要经过三个步骤

  1. 认证
  2. 授权
  3. 准入控制

• 进行访问的时候,过程中都需要经过apiserver

  1. apiserver做统一协调,比如门卫
  2. 访问过程中需要证书、token、或者用户名+密码
  3. 如果访问Pod需要serviceAccount账号

• 认证、传输安全

  1. 传输安全： 对外不暴露8080端口，只能内部访问，对外使用端口6443
  2. 认证： 客户端身份认证常用方式
     1. https证书、基于ca证书
     2. http 、token认证，通过token识别用户
     3. http 基本认证： 用户名+密码

• 授权

  • 基于RBAC进行鉴权操作： 基于角色控制访问
    1. 角色
       1. role: 特定命名空间访问权限
       2. ClusterRole：所有命名空间访问权限
    2. 角色绑定
       1. releBinding：角色绑定到主体
       2. ClusterRoleBinDing：集群角色绑定到主体
    3. 主体
       1. user：用户
       2. group：用户组
       3. serviceAccount： 服务账号

• 准入控制

  1. 就是准入控制器的列表，如果列表有请求内容，通过，没有拒绝

案例

1. 创建一个命名空间

kubectl create ns roledemo

2. 创建一个pod

kubectl run nginx --image=nginx -n roledemo
#  查看
kubectl get pod -n roledemo

3. 创建一个角色（Role）

vim rbac-role.yaml

kink: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: roledemo
  name: pod-reader
rules:
  - apiGroups: [""] # "" 表示核心API组
    resources: ["pods"]
    verbs: ["get", "watch", "list"] # 权限

# 创建
kubectl apply -f rbac-role.yaml
# 查看
kubectl get role -n roledemo

4. 创建角色绑定

vim rbac-rolebinding.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: roledemo
subjects:
  - kind: User
    name: username
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

# 创建
kubectl apply -f rbac-rolebinding.yaml
# 查看
kubectl get rolebinding -n roledemo

# 测试
kubectl get pods -n roledemo
kubectl get svc -n roledemo

Ingress

引入

• 把端口号对外保留，通过ip+端口号进行访问
  • 使用Service里面的NodePort实现
• NodePort 缺陷
  • 在每个节点上都会起到端口，在访问的时候通过任何节点的ip+暴露端口号实现访问
  • 意味着每个端口只能用一次，一个端口对应一个应用
  • 实际访问中都是用域名，根据不同域名跳转到不同端口服务中

Ingress和Pod关系

• pod和ingress通过service关联的
• ingress作用统一入口，有service关联一组pod

使用ingress对外暴露应用

1. 创建nginx应用，对外百六端口使用NodePort

# 创建pod
kubectl create deployment web --image=nginx
# 对外暴露
kubectl expose deployment web --port=80 --target-port=80 --type=NodePort

2. 部署ingress Controller

# 获取ingress-controller.yaml 文件
wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.30.0/deploy/static/mandatory.yaml
mv mandatory.yaml ingress-controller.yaml

# 在213行添加
hostNetwork: true
# 创建
kubectl apply -f ingress-controller.yaml
# 查看
kubectl get pods -n ingress-nginx

3. 创建ingress规则

vim ingress.yaml

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: example-ingress # 名字
spec:
  rules:
    - host: example.ingredemo.com # 域名
      http:
        paths:
          - path: /
            backend:
              serviceName: web # pod名字
              servicePort: 80 # 端口

# 创建
kubectl apply -f ingress.yaml

# 查看 pod
kubectl get pods -n ingress-nginx -o wide
kubectl get ing
# 在对应节点上查看端口
netstat -antp |grep 443
netstat -antp |grep 80

4. 在windows中进行域名映射

C:\Windows\System32\drivers\etc 目录下的hosts
增加域名映射

192.168.10.103 example.ingredemo.com

Helm

引入

• 之前方法部署应用基本过程
  1. 编写yaml文件
  2. deployment
  3. Service
  4. Ingress
• 如果是部署单一应用，少数服务的应用是比较合适的，如果多了，那么维护会很难
• 那么这些使用helm可以解决
  1. 使用helm可以把这些yaml作为一个整体管理
  2. 实现yaml高效复用
  3. 使用helm应用级别的版本管理

helm概念

1. helm：一个命令行客户端工具，主要用于 Kubernetes 应用 chart 的创建、打包、发布和管理。

2. Chart：应用描述，一系列用于描述 k8s 资源相关文件的集合。

3. Release：基于 Chart 的部署实体，一个 chart 被 Helm 运行后将会生成对应的一个release；将在 k8s 中创建出真实运行的资源对象。

安装helm和配置仓库

github地址：https://github.com/helm/helm/releases
下载地址

tar -zxvf helm-v3.0.0-linux-amd64.tar.gz
cd linux-amd64/
cp helm /usr/bin/

添加仓库

# 添加微软仓库
# weiruan ---> 仓库名
helm repo add weiruan  http://mirror.azure.cn/kubernetes/charts
# 添加阿里云仓库
helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
# 更新仓库
helm repo update
# 仓库列表
helm repo list
# 删除仓库
helm repo remove aliyun

快速部署

1. 使用命令搜索应用

helm search repo 应用名称
# 如：weave 是可视化监控
helm search repo weave

2. 根据搜索内容选择安装应用

helm install 安装后的名称 搜索的应用名称
# 如：
helm install ui weiruan/weave-scope
# 查看安装之后的状态
helm list
helm status 名称

# 修改ui的对外暴露端口
kubectl edit svc ui-weave-scope
# 通过浏览器查看

自定义chart

1. 创建chart文件夹

helm create mychart

2. chart文件夹说明
   1. Chart.yaml: 当前chart属性配置信息
   2. templates: 编写yaml文件放入此目录
   3. values.yaml：yaml文件可以使用的全局变量
3. 在template文件夹下编写自己的yaml

cd mychart
cd templates
# 删除templates中自带文件
rm -rf * 

# 创建 deployment.yaml
kubectl create deployment web1 --image=nginx --dry-run -o yaml > deployment.yaml

# 创建 service.yaml
kubectl expose deployment web1 --port=80 --target-port=80 --type=NodePort --dry-run -o yaml > service.yaml
# 如果这里报了未找到的错误，那么可以先创建出pod在执行

4. 安装

# 如果报安装冲突先删除前面创建的，或者修改yaml中名字
 cd ../../
 helm install web1 mychart/

5. 应用升级

helm upgrade web1 mychart/

yaml高效复用

1. 说明
     通过传递参数，动态渲染模板，yaml内容通过动态传入参数生成
2. 在values.yaml定义变量和值

replicas: 1
image: nginx
tag: 1.16
label: nginx
port: 80

3. 在具体yaml文件获取

# 后面的表达式是获取你创建时的传参
表达式： {{ .Values.变量名}} ||  {{ .Release.Name}}

修改deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: {{.Values.label}}
  name: {{ .Release.Name}}-deploy
spec:
  replicas: {{.Values.replicas}}
  selector:
    matchLabels:
      app: {{.Values.label}}
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: {{.Values.label}}
    spec:
      containers:
      - image: {{.Values.image}}
        name: nginx
        resources: {}
status: {}

修改service.yaml

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    app: {{.Values.label}}
  name: {{ .Release.Name}}-service
spec:
  ports:
  - port: {{ .Values.port}}
    protocol: TCP
    targetPort: 80
  selector:
    app: {{ .Values.label}}
  type: NodePort
status:
  loadBalancer: {}

4. 安装

# 尝试执行，可以查看生成的yaml文件
helm install --dry-run web2 mychart/
# 执行
helm install web2 mychart/

持久化存储

nfs网络存储

1. 用一台服务器做nfc服务端
2. 安装nfs

yum -y install nfs-utils

3. 设置挂载路径

vim /etc/exports
# /opt/data/nfs 是挂载路径
# *表示所有内容 rw表示读写权限
/opt/data/nfs *(rw,no_root_squash)

mkdir -p /opt/data/nfs

4. 在node节点上安装nfs

yum -y install nfs-utils

5. 在nfs服务端启动

systemctl start nfs
ps -ef | grep nfs

6. 创建yaml文件

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-nfs1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          volumeMounts:
            - name: wwwroot
              mountPath: /opt/temp/html
          ports:
            - containerPort: 80
      volumes:
         - name: wwwroot
           nfs:
             server: 192.168.10.101
             path: /opt/data/nfs

kubectl apply -f nfs.yaml
kubectl get pods
kubectl exec -it nginx-nfs1-6545f8b7fd-ch5qb bash

cd /opt/temp/html/
ls
# 执行下面代码后
ls

# 在nfs服务端上
cd /opt/data/nfs/
vim index.html
# 随便写点内容

pv和pvc

1. pv: 持久化存储，对存储资源进行抽象，对外提供可以调用的地方
2. pvc: 用于调用，不需要关系内部实现细节
3. 实现流程
   应用部署—> 定义pvc（绑定pv）—> 定义pv（数据存储服务器ip，路径，存储容量，匹配模式）
4. 实操

vim /opt/pv/pvc.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-nfs1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx
          volumeMounts:
            - name: wwwroot
              mountPath: /usr/share/nginx/html
          ports:
            - containerPort: 80
      volumes:
         - name: wwwroot
           persistentVolumeClaim:
             claimName: my-pvc

---

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteMany # 读写
  resources:
    requests:
      storage: 5Gi # 容量

kubectl apply -f pvc.yaml

vim /opt/pv/pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteMany
  nfs:
    path: /opt/data/nfs
    server: 192.168.10.101

查看

kubectl get pv,pvc