Kubernetes基础

最新推荐文章于 2021-12-16 23:08:09 发布

weixin_33762321

最新推荐文章于 2021-12-16 23:08:09 发布

阅读量179

点赞数

文章标签：开发工具 java json

原文链接：https://my.oschina.net/logmm/blog/2045260

版权

为什么80%的码农都做不了架构师？>>>

一、kubernets简介

1、kubernets是什么

中文社区文档：http://docs.kubernetes.org.cn/

https://www.kubernetes.org.cn/k8s

Kubernetes，简称K8s，是用8代替8个字符“ubernete”而成的缩写。是容器集群管理系统，是一个开源的平台，可以实现容器集群的自动化部署、自动扩缩容、维护等功能（Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications.）。

传统的应用部署方式是通过插件或脚本来安装应用。这样做的缺点是应用的运行、配置、管理、所有生存周期将与当前操作系统绑定，这样做并不利于应用的升级更新/回滚等操作，当然也可以通过创建虚机的方式来实现某些功能，但是虚拟机非常重，并不利于可移植性。

通过Kubernetes你可以：

快速部署应用
快速扩展应用
无缝对接新的应用功能
节省资源，优化硬件资源的使用

我们的目标是促进完善组件和工具的生态系统，以减轻应用程序在公有云或私有云中运行的负担。

2、kubernets特点

可移植: 支持公有云，私有云，混合云，多重云（multi-cloud）
可扩展: 模块化, 插件化, 可挂载, 可组合
自动化: 自动部署，自动重启，自动复制，自动伸缩/扩展

实际上，使用Kubernetes只需一个部署文件，使用一条命令就可以部署多层容器（前端，后台等）的完整集群。

二、kubernetes集群架构

（1）集群及相关概念介绍

集群中有master/node，集群中node最小单元是Pod。

master：API Server，Scheduler，Controller-Manager

node：kubelet，docker，。。。

相关概念介绍：

1、Master：是整个集群的控制中心，kubernetes的所有控制指令是发给master，它负责具体的执行过程。一般情况下，把master独立于一台机子上。

master上关键的进程有：

kubernetes API Server（kube-apiserver）：提供了HTTP Rset接口关键服务进程，是所有资源增、删、改、查等操作的唯一入口，也是集群控制的入口进程。

kubernetes Controller Manager（kube-controller-manager）：是所有资源对象的自动化控制中心，可以理解为资源对象的大总管。

kubernetes Scheduler（kube-scheduler）：负载资源调度（pod调度）的进程，相当于公交公司的“调度室”。

etcd Server：kubernets的所有资源对象的数据都是存储在etcd中。

2、Node：除了master，kubernetes集群中的其他机器被称为Node，早期版本中叫做Minion。Node可以是物理机，也可以是虚拟机，每个Node上会被分配一些工作负载（即，docker容器），当Node宕机后，其上面跑的应用会被转移到其他Node上。

Node关键进程有：

kubelet：负载Pod对应容器的创建、启停等任务，同时与Master节点密切工作，实现集群管理的基本功能。

kube-proxy：实现kubernetes service的通信与负载均衡机制的重要组件。

Docker Engine（docker）：Dcoker引擎，负载本机容器的创建和管理。

3、Pod：是Kubernetes创建或部署的最小/最简单的基本单位，一个Pod代表集群上正在运行的一个进程。

一个Pod封装一个应用容器（也可以有多个容器），存储资源、一个独立的网络IP以及管理控制容器运行方式的策略选项。Pod代表部署的一个单位：Kubernetes中单个应用的实例，它可能由单个容器或多个容器共享组成的资源。

每个pod对应两个容器，一个是Pause容器，一个是rc里面定义的容器（可以有多个应用容器），这个Pause称为“根容器”。Pause容器的IP以及挂载的Volume资源会共享给该pod下的其他容器。

每个pod都可以对其能使用的服务器上的硬件资源进行限制（比如cpu、内存）。cpu限定的最小单位是1/1000个cpu，用m表示，比如10m，表示0.1个cpu。内存限定的最小单位是字节，可以用兆（Mi）表示，如128Mi也就是128M。

在kubernetes里，一个计算资源进行配额限定需要设定两个参数：

request：该资源的最小申请量

Limits：该资源允许的最大使用量。

4、Label：是一个键值对，其中键和值都由用户自定义，Label可以附加在各种资源对象上，如Node、Pod、Service、RC等。一个资源对象可以定义多个Label，同一个Label也可以被添加到任意数量的资源对象上。Label可以在定义对象时定义，也可以在对象创建完成后动态添加或删除。

Label示例：

"release":"stable","environment":"dev","tier":"backend"等。

5、RC：kubernetes中核心概念之一，简单说它定义了一个期望的场景，即声明某种Pod的副本数量在任意时刻都符合某个预期值，RC定义了如下几个部分：

1）pod期待的副本数

2）用于筛选目标pod的Label Selector

3）创建pod副本的模版（template）

RC一旦被提交到kubernetes集群后，Master节点上的Controller Manager组件就会收到该通知，它会定期巡检集群中存活的pod，并确保pod数量符合RC的定义值。可以说，通过RC，kubernetes实现了用户应用集群的高可用性，并且大大减少了管理员在传统IT环境中不得不做的诸多手动运维工作，比如编写监控脚本、应用监控脚本、故障恢复处理脚本等等。

RC工作流程（假设，集群中有3个Node）：

1）RC定义2个pod副本

2）假设系统会在2个Node上（Node1、Node2）创建pod

3）如果Node2上的pod（pod2）意外终止，这很有可能是因为Node2宕机

4）则会创建一个新的pod，假设会在Node3上创建pod3，当然也有可能在Node1上创建pod3

RC中动态修改pod副本数量：

kubectl scale rc <rc name> --replicas=n

利用动态修改pod的副本数，可以实现应用的动态升级（滚动升级）：

1）以新版本的镜像定义新的RC，但pod要和旧版本保持一致（由Label决定）

2）新版本每增加1个pod，就版本就会减少1个pod，始终保持固定值

3）最终旧版本pod数为0，全部为新版本

删除RC：kubectl delete rc <rc name>

删除RC后，RC对应的pod也会被删除。

6、Deployment：在1.2版本中引入的概念，目的是为了解决pod编排问题，在内部使用了Replica Set，它和RC比较，相似度90%以上，可以认为是RC的升级版，跟RC比较，最大的一个特点是可以知道pod部署的进度。

Deployment示例：

[root@lb01 ~]# vim tomcat-deployment.yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      tier: frontend
    matchExpressions:
      - {key: tier, operator: In, values: [frontend]}
  template:
    metadata:
      labels:
        app: app-demo
        tier: frontend
    spec:
      containers:
      - name: tomcat-demo
        image: tomcat
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

创建：

[root@lb01 ~]# kubectl create -f tomcat-deployment.yaml 
deployment "frontend" created
[root@lb01 ~]#
[root@lb01 ~]# kubectl get deployment 
NAME       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
frontend   1         1         1            1           2m
[root@lb01 ~]#

创建成功。查看详情：

[root@lb01 ~]# kubectl get pods
NAME                       READY     STATUS    RESTARTS   AGE
frontend-141477217-j771q   1/1       Running   0          4m
mysql-1t0kh                1/1       Running   0          4h
myweb-s5msl                1/1       Running   0          3h
[root@lb01 ~]# kubectl describe pod frontend-141477217-j771q
Name:		frontend-141477217-j771q
Namespace:	default
Node:		127.0.0.1/127.0.0.1
Start Time:	Sat, 13 Oct 2018 21:10:00 +0800
Labels:		app=app-demo
		pod-template-hash=141477217
		tier=frontend
Status:		Running
IP:		172.17.0.4
Controllers:	ReplicaSet/frontend-141477217
Containers:
  tomcat-demo:
    Container ID:		docker://c4657b8cf8684a3a82f46d098c2d825417929e2866490515339fbc4fd3cbca6d
    Image:			tomcat
    Image ID:			docker-pullable://docker.io/tomcat@sha256:8d120de5102cc12310de741299e9bf6f39d2d674663f2ce4e6f0f181ccfeebe7
    Port:			8080/TCP
    State:			Running
      Started:			Sat, 13 Oct 2018 21:10:00 +0800
    Ready:			True
    Restart Count:		0
    Volume Mounts:		<none>
    Environment Variables:	<none>
Conditions:
  Type		Status
  Initialized 	True 
  Ready 	True 
  PodScheduled 	True 
No volumes.
QoS Class:	BestEffort
Tolerations:	<none>
Events:
  FirstSeen	LastSeen	Count	From			SubObjectPath			Type		Reason			Message
  ---------	--------	-----	----			-------------			--------	------			-------
  5m		5m		1	{default-scheduler }					Normal		Scheduled		Successfully assigned frontend-141477217-j771q to 127.0.0.1
  5m		5m		2	{kubelet 127.0.0.1}					Warning		MissingClusterDNS	kubelet does not have ClusterDNS IP configured and cannot create Pod using "ClusterFirst" policy. Falling back to DNSDefault policy.
  5m		5m		1	{kubelet 127.0.0.1}	spec.containers{tomcat-demo}	Normal		Pulled			Container image "tomcat" already present on machine
  5m		5m		1	{kubelet 127.0.0.1}	spec.containers{tomcat-demo}	Normal		Created			Created container with docker id c4657b8cf868; Security:[seccomp=unconfined]
  5m		5m		1	{kubelet 127.0.0.1}	spec.containers{tomcat-demo}	Normal		Started			Started container with docker id c4657b8cf868
[root@lb01 ~]#

7、HPA（Horizontail Pod Autoscaler）：在1.1版本中，发布了HPA，实现pod的动态扩容，它属于一种kubernetes的资源对象，它通过追踪分析RC控制的所有目标pod的负载变化情况，来决定是否需要针对性地调整目标Pod的副本数，这就是HPA的实现原理。

pod负载度量指标：

1）CpuUtillizationPercentage

目标pod所有副本自身的cpu利用率平均值。

一个pod自身的cpu利用率=该pod当前cpu的使用量/pod Request值。

如果某一时刻，CpuUtillizationPercentage的值超过了80%，则判断当前的pod已经不够支撑业务，需要增加pod。

2）应用程序自定义的度量指标，比如服务每秒内的请求数（TPS或QPS）

HPA示例：

[root@lb01 ~]# vim hpa.yaml
apiVersion: autosacling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
  namespace: default
spec:
  maxRplicas: 10
  minRplicas: 1
  scaleTargetRef:
   kind: Deployment
   name: php-apache
  targetCPUUtillizationPercentage: 90

示例说明：HPA控制的目标对象是一个名叫php-apache的Deployment里的pod副本，当cpu平均值超过90%时就会扩容，pod副本数控制范围是1-10

此外，可以使用命令行的方式定义：

kubectl autoscale deployment php-apache --cpu-percent=90 --min=1 --max=10

8、Service：是kubernetes中最核心的资源对象之一，Service可以理解成是微服务架构中的一个"微服务“，pod、RC、Deployment都是为Service提供嫁衣的。

简单讲，一个service本质上是一组pod组成的一个集群，service和pod之间是通过Label串起来，相同的Service的pod的Label是一样的。同一个service下的所有pod是通过kibe-proxy实现负载均衡，而每个service都会分配一个全局唯一的虚拟ip，也就cluster ip。在该service整个生命周期内，cluster ip保持不变，而在kubernetes中还有一个dns服务，它把service的name和cluster ip应声起来。

示例：

[root@lb01 ~]# vim tomcat-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: tomcat-service
spec:
  ports:
   - port: 8080
   selector:
    tier: frontend

查看pod的IP和端口：

[root@lb01 ~]# kubectl get endpoints 
NAME         ENDPOINTS             AGE
kubernetes   192.168.10.101:6443   5h
mysql        172.17.0.3:3306       4h
myweb        172.17.0.2:8080       4h
[root@lb01 ~]#

或者：

[root@lb01 ~]# kubectl get svc mysql -o yaml
apiVersion: v1
kind: Service
metadata:
  creationTimestamp: 2018-10-13T08:56:25Z
  name: mysql
  namespace: default
  resourceVersion: "3540"
  selfLink: /api/v1/namespaces/default/services/mysql
  uid: dd5acf33-cec5-11e8-99b8-000c296526e7
spec:
  clusterIP: 10.254.30.203
  ports:
  - port: 3306
    protocol: TCP
    targetPort: 3306
  selector:
    app: mysql
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}
[root@lb01 ~]#

多端口的service：

apiVersion: v1
kind: Service
metadata:
  name: tomcat-service
spec:
  ports:
   - port: 8080
     name: service-port
   - port: 8005
     name: shutdown-port
   selector:
     tier: frontend

对于cluster ip的限制：

1）cluster ip无法被ping通，因为没有实体网络来响应

2）cluster ip和Service port组成了一个具体的通信端口，单独的cluster ip不具备TCP/IP通信基础，它们属于一个封闭的空间。

3）在kubernetes集群中，Node ip、pod ip 、cluster ip之间的通信，采用的是kubernetes自己设计的一套编程方式的特殊路由规则。

想要和service直接通信，需要一个Nodeport，在service的yaml文件中定义：

apiVersion: v1
kind: Service
metadata:
  name: romcat-srvice
spec:
  ports:
   - port: 8080
     nodeport: 30001
  selector:
    tier: frontend

9、Volume（存储卷）：是pod中能够被多个容器访问的共享目录，kubernetes中的volume跟docker中的volume不一样，主要有以下几个方面：

1）kubernetes的volume定义在pod上，然后被一个pod里的多个容器挂载到具体的目录中

2）kubernetes的volume与pod生命周期相同，但与容器的生命周期无关，当容器终止或重启时，volume中的数据并不会丢失

3）kubernetes支持多种类型的volume，如glusterfs、ceph等先进的分布式文件系统。

在定义pod的yaml文件中指定volume相关配置即可，比如：

template:
  metadata:
    labels:
       app: app-demo
       tier: frontend
  spec:
    volumes:
      - name: datavol
        emptyDir: {}
      containers:
      - name: tomcat-demo
        image: tomcat
        volumeMounts:
          - mountPath: /mydata-data
            name: datavol
        imagePullPolicy: IfNotPresent

说明：volume名字是datavol，类型是emptyDir，将volume挂载到容器的/mydata-data目录下。

volume的类型：

1）emptyDir：在pod分配到node时创建，初始内容为空，不需要关心它将会在宿主机（node）上的哪个目录下，因为这是kubernetes自动分配的一个目录，当pod从node上移除，emptyDir上的数据也会消失。所以，这种类型的volume不适合存储永久数据。

2）hostPath：hostPath指定宿主机（node）上的目录路径，然后pod里的容器挂载该共享目录。如果是多个node，虽然目录一样，但是数据不能做到一致，因此，这个类型适合一个node。

配置示例：

volumes：
  - name: "persistent-storage"
    hostPath:
      path: "/data"

3）gcePersistentDisk：使用Google公有云GCE提供的永久磁盘（PD）存储volume数据。毫无疑问，使用gcePersistentDisk的前提是kubernetes的node是基于GCE的。

配置示例：

volumes:
  - name: test-volume
    gcePersistentDisk:
      pdName: my-data-disk
      fsType: ext4

4）awsElasticBlockStore：与GCE类似，该类型使用亚马逊公有云提供的EBS Volume存储数据，使用它的前提是Node必须是aws EC2。

5）NFS：使用NFS作为volume载体。

示例：

volume:
  - name: "NFS"
    NFS：
      server: 服务端ip
      path: "/"

6）其他类型：iscsi、flocker、glusterfs、rbd、gitRepo（从git仓库clone一个项目，以供pod使用）、secret（用于为pod提供加密的信息）。

10、persistent volume（PV）：PV可以理解成kubernetes集群中某个网络存储中对应的一块存储，它与volume类似，但区别如下：

1）PV只能是网络存储，不属于任何Node，但可以在每个node上访问到

2）PV并不是定义在pod上，而是独立于pod之外定义

3）PV目前类型有：GCE Persistent Disk、NFS、RBD、iSCSI、AWS ElasticBlockStore、GlusterFS。

示例：NFS类型的定义

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv003
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteOnce
  nfs:
    path: 目录
    server: ip

说明：其中accessModes是一个重要的属性，其类型有：

ReadWriteOnce：读写权限，并且只能被单个Node挂载

ReadOnlyMany：只读，允许被多个Node挂载

ReadWriteMany：读写权限，允许被多个Node挂载

如果某个pod想申请某种条件的PV，首先需要定义一个PersistentVolumeClaim（PV）对象：

kind: persistentVolumeClaim
apiVersion: v1
metadata:
  name: myclaim
spec:
  accessModes:
   - ReadWriteOnce
  resources:
    requests:
      storage: 8Gi

然后在pod的volume定义中引用上面的PV：

volumes：
  - name: mypd
    persistentVolumeClaim:
      ClaimName: myclaim

11、Namespace（命名空间）：当kubernetes集群中存在多租户的情况下，就需要有一种机制实现每个租户的资源隔离，而namespace的目的就是为了实现资源隔离。

查看所有的命名空间：kubectl get namespace

定义namespace：

[root@lb01 ~]# vim dev-namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: dev

创建：

[root@lb01 ~]# kubectl create -f dev-namespace.yaml 
namespace "dev" created
[root@lb01 ~]#

创建好namespace后，定义pod，指定namespace：

[root@lb01 ~]# vim dev-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: busybox
  namespace: dev
spec:
  containers:
  - image: busybox
    command:
      - sleep
      - "500"
    name: busybox
[root@lb01 ~]# kubectl create -f dev-pod.yaml 
pod "busybox" created
[root@lb01 ~]#

查看一下，

[root@lb01 ~]# kubectl get pods -n dev
NAME      READY     STATUS    RESTARTS   AGE
busybox   1/1       Running   0          52s
[root@lb01 ~]# kubectl get pods --all-namespaces 
NAMESPACE   NAME                       READY     STATUS    RESTARTS   AGE
default     frontend-141477217-j771q   1/1       Running   2          18h
default     mysql-1t0kh                1/1       Running   2          22h
default     myweb-s5msl                1/1       Running   2          22h
dev         busybox                    1/1       Running   0          1m
[root@lb01 ~]#

OK，自定义的namespace，pod成功。

（2）kubectl命令用法

（1）、kubectl语法：kubectl [command] [TYPE] [NAME] [flags]

1、command，子命令，用于操作kubernetes集群资源对象的命令，如create、delete、describe、get、apply等等。

2、TYPE，资源对象的类型，如pod、service、rc、deployment、node等，可以是单数也可以数复数或简写（pod，pods，po；service，services，svc）

3、NAME，资源对象的名称，不指定则返回所有，如get pod会返回所有的pod，get pod nginx，则返回nginx这个pod

4、flags，kubectl子命令的可选参数，例如，-n指定namespace，-s指定apiserver的URL。

（2）资源对象类型列表

获取资源对象：kubectl api-versions

资源对象简写：

componentsstatuses 简写：cs

daemonsets 简写：ds

deployment 简写：deploy

events 简写：ev

endpoints 简写：ep

horizontalpodautoscalers 简写：hpa

ingresses 简写：ing

jobs 没有简写

limitranges 简写：limits

nodes 简写：no

namespace 简写：ns

pods 简写：po

persisentvolumes 简写：pv

persisentvolumeclaims 简写：pvs

resourcequotas 简写：quota

replicationcontroller 简写：rc

secrets 无简写

serviceaccounts 简写：sa

services 简写：svc

特殊用法：

kubectl get pods pod1 pod2

kubectl get pod/pods rc/rc1

kubectl create -f 文件1 -f 文件2 ...

使用-o选项，可以显示更多信息：

[root@lb01 ~]# kubectl get pod -o wide
NAME                       READY     STATUS    RESTARTS   AGE       IP           NODE
frontend-141477217-j771q   1/1       Running   2          18h       172.17.0.3   127.0.0.1
mysql-1t0kh                1/1       Running   2          23h       172.17.0.2   127.0.0.1
myweb-s5msl                1/1       Running   2          22h       172.17.0.4   127.0.0.1
[root@lb01 ~]# kubectl get pod
NAME                       READY     STATUS    RESTARTS   AGE
frontend-141477217-j771q   1/1       Running   2          18h
mysql-1t0kh                1/1       Running   2          23h
myweb-s5msl                1/1       Running   2          22h
[root@lb01 ~]#

-o支持的格式有：

custom-columns=<spec>：根据自定义列名输出，逗号分隔

custom-columns-file=<filename>：从文件中获取自定义列名进行输出

json：以JSON格式显示结果

jsonpath=<template>：输出jsonpath表达式定义的字段信息

jsonpath-file=<filename>：输出jsonpath表达式定义的字段信息，来源于文件

name：仅输出资源对象的名称

wide：输出更多信息

yaml：以yaml格式输出。

（3）部分命令演示

1、查看所有pod

[root@lb01 ~]# kubectl get pods
NAME                       READY     STATUS    RESTARTS   AGE
frontend-141477217-j771q   1/1       Running   2          18h
mysql-1t0kh                1/1       Running   2          23h
myweb-s5msl                1/1       Running   2          22h
[root@lb01 ~]#

2、查看deployment和service

[root@lb01 ~]# kubectl get deploy,svc
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deploy/frontend   1         1         1            1           18h

NAME             CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
svc/kubernetes   10.254.0.1      <none>        443/TCP          23h
svc/mysql        10.254.30.203   <none>        3306/TCP         23h
svc/myweb        10.254.53.239   <nodes>       8080:30001/TCP   22h
[root@lb01 ~]#

3、显示node详细信息

[root@lb01 ~]# kubectl get nodes
NAME        STATUS    AGE
127.0.0.1   Ready     23h
[root@lb01 ~]# kubectl describe nodes 127.0.0.1
Name:			127.0.0.1
Role:			
Labels:			beta.kubernetes.io/arch=amd64
			beta.kubernetes.io/os=linux
			kubernetes.io/hostname=127.0.0.1
Taints:			<none>
CreationTimestamp:	Sat, 13 Oct 2018 16:03:40 +0800
Phase:			
Conditions:
  Type			Status	LastHeartbeatTime	
....

4、显示pod详细信息

[root@lb01 ~]# kubectl get pod
NAME                       READY     STATUS    RESTARTS   AGE
frontend-141477217-j771q   1/1       Running   2          18h
mysql-1t0kh                1/1       Running   2          23h
myweb-s5msl                1/1       Running   2          22h
[root@lb01 ~]# kubectl describe pods mysql-1t0kh
Name:		mysql-1t0kh
Namespace:	default
Node:		127.0.0.1/127.0.0.1
Start Time:	Sat, 13 Oct 2018 16:38:19 +0800
Labels:		app=mysql
Status:		Running
IP:		172.17.0.2
。。。。

5、显示deployment管理的pod信息

[root@lb01 ~]# kubectl get deployment 
NAME       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
frontend   1         1         1            1           18h
[root@lb01 ~]# kubectl describe pods frontend
Name:		frontend-141477217-j771q
Namespace:	default
Node:		127.0.0.1/127.0.0.1
Start Time:	Sat, 13 Oct 2018 21:10:00 +0800
Labels:		app=app-demo
		pod-template-hash=141477217
		tier=frontend
Status:		Running
。。。

6、删除资源对象

基于yaml文件删除：

[root@lb01 ~]# kubectl delete -f dev-pod.yaml 
pod "busybox" deleted
[root@lb01 ~]#

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

kubectl delete po,svc -l name=label名

删除所有的pod：kubectl delete po --all

7、执行容器的命令

在pod中执行某个命令：kubectl exec <pod名> 命令

如：kubectl exec mysql-1t0kh date

指定pod的某个容器执行命令：kubectl exec -it <pod名> 命令

如：kubectl exec -it mysql-1t0kh bash

8、查看容器日志

kubectl logs <pod name>

kubectl logs -f <pod name> -c <容器名>

三、从一个例子开始

webapp+mysql

系统环境：RHEL7.5，ip：192.168.10.101，内存3G，关闭防火墙和selinux。

（一）安装kuberntes

1、安装etcd和kubernetes

[root@lb01 ~]# yum install -y etcd kubernetes

2、修改配置文件

因为docker仓库默认使用https，这里没有配https，所以要修改配置文件，不使用https。

[root@lb01 ~]# vim /etc/sysconfig/docker

修改：

把：OPTIONS='--selinux-enabled --log-driver=journald --signature-verification=false'

改为：OPTIONS='--selinux-enabled=false --insecure-registry gcr.io --log-driver=journald --signature-verification=false'

[root@lb01 ~]# vim /etc/kubernetes/apiserver

修改：

把：KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota"中的ServiceAccount删除，变成：

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

4、准备工作

安装python-rhsm-certificates软件包。

[root@lb01 ~]# yum install python-rhsm-certificates
已加载插件：fastestmirror, product-id, search-disabled-repos, subscription-manager
This system is not registered with an entitlement server. You can use subscription-manager to register.
Loading mirror speeds from cached hostfile
 * epel: mirrors.tuna.tsinghua.edu.cn
软件包 python-rhsm-certificates-1.19.10-1.el7_4.x86_64 被已安装的 subscription-manager-rhsm-certificates-1.20.11-1.el7.centos.x86_64 取代
无须任何处理
[root@lb01 ~]#

报错，解决方法：安装python-rhsm-certificates-1.19.10-1.el7_4.x86_64.rpm

[root@lb01 ~]# curl -O http://mirror.centos.org/centos/7/os/x86_64/Packages/python-rhsm-certificates-1.19.10-1.el7_4.x86_64.rpm
[root@lb01 ~]# rpm2cpio python-rhsm-certificates-1.19.10-1.el7_4.x86_64.rpm | cpio -iv --to-stdout ./etc/rhsm/ca/redhat-uep.pem > /etc/rhsm/ca/redhat-uep.pem
./etc/rhsm/ca/redhat-uep.pem
17 块
[root@lb01 ~]#

配置docker加速器：

[root@lb01 ~]# vim /etc/docker/daemon.json
{
 "registry-mirrors": ["https://1xesnmzk.mirror.aliyuncs.com","http://hub-mirror.c.163.com","https://registry.docker-cn.com"]
}

5、按顺序启动服务

[root@lb01 ~]# for server in etcd docker kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy; do systemctl start $erver; done
[root@lb01 ~]#

（二）创建mysql service

1、创建一个mysql rc文件

rc：replication controller。

[root@lb01 ~]# vim mysql-rc.yaml
apiVersion: v1
kind: ReplicationController            #副本控制器RC
metadata:  
  name: mysql                          #RC的名称，全局唯一
spec:
  replicas: 1                          #Pod副本的期待数量
  selector:
    app: mysql                         #符合目标的Pod拥有此标签
  template:                            #根据此模版创建Pod的副本（实例）
    metadata:
       labels:
         app: mysql                    #Pod副本拥有的标签，对应RC的selector
    spec:
       containers:                     #Pod内，定义容器
       - name: mysql                   #容器名称
         image: mysql:5.6              #Docker image
         ports:
         - containerPort: 3306         #容器应用监听的端口
         env:                          #注入容器内的环境变量
         - name: MYSQL_ROOT_PASSWORD   #这里设置root初始密码
           value: "123456"

注意空格。

2、创建mysql rc

[root@lb01 ~]# kubectl create -f mysql-rc.yaml 
replicationcontroller "mysql" created
[root@lb01 ~]#

查看rc:

[root@lb01 ~]# kubectl get rc
NAME      DESIRED   CURRENT   READY     AGE
mysql     1         1         0         56s
[root@lb01 ~]#

查看pod：

[root@lb01 ~]# kubectl get pod
NAME          READY     STATUS              RESTARTS   AGE
mysql-1t0kh   0/1       ContainerCreating   0          2m
[root@lb01 ~]#

容器创建中。需要等待一段时间

经过漫长的等待之后，查看镜像：

[root@lb01 ~]# docker images
REPOSITORY                                            TAG                 IMAGE ID            CREATED             SIZE
docker.io/mysql                                       5.6                 1f47fade220d        5 weeks ago         256 MB
registry.access.redhat.com/rhel7/pod-infrastructure   latest              99965fb98423        12 months ago       209 MB
[root@lb01 ~]#

镜像下载成功。

再次查看pod：

[root@lb01 ~]# kubectl get pod
NAME          READY     STATUS    RESTARTS   AGE
mysql-1t0kh   1/1       Running   0          3m
[root@lb01 ~]#

OK，pod运行中。rc创建成功。

3、创建mysql serveice

查看一下：

[root@lb01 ~]# kubectl get service
NAME         CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   10.254.0.1   <none>        443/TCP   40m
[root@lb01 ~]# kubectl get svc
NAME         CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   10.254.0.1   <none>        443/TCP   40m
[root@lb01 ~]#

只有默认的service，下面创建一个mysql的service。

创建yaml文件：

[root@lb01 ~]# vim mysql-svc.yaml
apiVsersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
    - port: 3306
  selector:
    app: mysql

创建：

[root@lb01 ~]# kubectl create -f mysql-svc.yaml 
service "mysql" created
[root@lb01 ~]#

查看一下service：

[root@lb01 ~]# kubectl get svc
NAME         CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
kubernetes   10.254.0.1      <none>        443/TCP    53m
mysql        10.254.30.203   <none>        3306/TCP   54s
[root@lb01 ~]#

OK，mysql service创建成功。

访问mysql：

[root@lb01 ~]# yum install mariadb -y
[root@lb01 ~]# mysql -uroot -p123456 -h10.254.30.203 -P3306
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.6.41 MySQL Community Server (GPL)

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)

MySQL [(none)]>

OK，mysql登录成功。

（三）创建web service

1、创建web rc

这里使用tomcat。

[root@lb01 ~]# vim myweb-rc.yaml
kind: ReplicationController
metadata:
  name: myweb
spec:
  replicas: 1
  selector:
    app: myweb
  template:
    metadata:
      labels:
        app: myweb
    spec:
      containers:
      - name: myweb
        image: kubeguide/tomcat-app:v1
        ports:
        - containerPort: 8080
        env:
        - name: MYSQL_SERVICE_HOST
          value: '10.254.30.203'
        - name: MYSQL_SERVICE_PORT
          value: '3306'

创建rc：

[root@lb01 ~]# kubectl create -f myweb-rc.yaml 
replicationcontroller "myweb" created
[root@lb01 ~]#

2、创建web service

[root@lb01 ~]# vim myweb-svc.yaml
kind: Service
metadata:
  name: myweb
spec:
  type: NodePort
  ports:
    - port: 8080
      nodePort: 30001
  selector:
    app: myweb

创建service：

[root@lb01 ~]# kubectl create -f  myweb-svc.yaml
service "myweb" created
[root@lb01 ~]#

查看pod、svc等。

[root@lb01 ~]# kubectl get pod
NAME          READY     STATUS    RESTARTS   AGE
mysql-1t0kh   1/1       Running   0          44m
myweb-s5msl   1/1       Running   0          8m
[root@lb01 ~]# kubectl get svc
NAME         CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes   10.254.0.1      <none>        443/TCP          1h
mysql        10.254.30.203   <none>        3306/TCP         26m
myweb        10.254.53.239   <nodes>       8080:30001/TCP   2m
[root@lb01 ~]# docker images
REPOSITORY                                            TAG                 IMAGE ID            CREATED             SIZE
docker.io/mysql                                       5.6                 1f47fade220d        5 weeks ago         256 MB
registry.access.redhat.com/rhel7/pod-infrastructure   latest              99965fb98423        12 months ago       209 MB
docker.io/kubeguide/tomcat-app                        v1                  a29e200a18e9        2 years ago         358 MB
[root@lb01 ~]#

至此，web+mysql service创建成功。

（四）测试

[root@lb01 ~]# curl -I 192.168.10.101:30001
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: text/html;charset=UTF-8
Transfer-Encoding: chunked
Date: Sat, 13 Oct 2018 09:30:11 GMT

[root@lb01 ~]# curl -I 10.254.53.239:8080
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: text/html;charset=UTF-8
Transfer-Encoding: chunked
Date: Sat, 13 Oct 2018 09:30:24 GMT

[root@lb01 ~]#

打开防火墙转发：

[root@lb01 ~]# iptables -P FORWARD ACCEPT
[root@lb01 ~]#

浏览器打开：192.168.10.101:30001

打开：192.168.10.101:30001/demo

点击add，添加信息：

登录mysql数据库查看一下：

[root@lb01 ~]# mysql -uroot -p123456 -h10.254.30.203 -P3306
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 7
Server version: 5.6.41 MySQL Community Server (GPL)

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| HPE_APP            |
| mysql              |
| performance_schema |
+--------------------+
4 rows in set (0.11 sec)

MySQL [(none)]>

多了一个HPE_APP数据库。

转载于:https://my.oschina.net/logmm/blog/2045260