kubernetes_kubernetes pvc - CSDN
精华内容
参与话题
  • 轻松上手Kubernetes教程

    2019-08-28 16:53:51
    Kubernetes是一个开源的,用于管理云平台中多个主机上的容器化的应用,Kubernetes的目标是让部署容器化的应用简单并且高效(powerful),Kubernetes提供了应用部署,规划,更新,维护的一种机制。 Kubernetes一个...
  • Kubernetes

    千次阅读 2016-04-14 11:13:10
    1. Kubernetes介绍 基本概念 Pod  Pod是Kubernetes的基本操作单元,把相关的一个或多个容器构成一个Pod,通常Pod里的容器运行相同的应用。Pod包含的容器运行在同一个Node(Host)上,看作一个统一管理单元,共享...

    1. Kubernetes介绍

    基本概念

    • Pod 
      Pod是Kubernetes的基本操作单元,把相关的一个或多个容器构成一个Pod,通常Pod里的容器运行相同的应用。Pod包含的容器运行在同一个Node(Host)上,看作一个统一管理单元,共享相同的volumes和network namespace/IP和Port空间。
    • Replication Controller 
      Replication Controller确保任何时候Kubernetes集群中有指定数量的pod副本(replicas)在运行, 如果少于指定数量的pod副本(replicas),Replication Controller会启动新的Container,反之会杀死多余的以保证数量不变。Replication Controller使用预先定义的pod模板创建pods,一旦创建成功,pod 模板和创建的pods没有任何关联,可以修改pod 模板而不会对已创建pods有任何影响,也可以直接更新通过Replication Controller创建的pods。对于利用pod 模板创建的pods,Replication Controller根据label selector来关联,通过修改pods的label可以删除对应的pods。
    • Service 
      Service也是Kubernetes的基本操作单元,是真实应用服务的抽象,每一个服务后面都有很多对应的容器来支持,通过Proxy的port和服务selector决定服务请求传递给后端提供服务的容器,对外表现为一个单一访问接口,外部不需要了解后端如何运行,这给扩展或维护后端带来很大的好处。
    • Label 
      Label是用于区分Pod、Service、Replication Controller的key/value键值对,Pod、Service、 Replication Controller可以有多个label,但是每个label的key只能对应一个value。Labels是Service和Replication Controller运行的基础,为了将访问Service的请求转发给后端提供服务的多个容器,正是通过标识容器的labels来选择正确的容器。同样,Replication Controller也使用labels来管理通过pod 模板创建的一组容器,这样Replication Controller可以更加容易,方便地管理多个容器,无论有多少容器。

    架构

    这里写图片描述
    Kubernets属于主从的分布式集群架构,包含Master和Node:

    1. Master作为控制节点,调度管理整个系统,包含以下组件:组件构成,包括Master节点上的kube-apiserver、kube-scheduler、kube-controller-manager、控制组件kubectl、状态存储etcd、Slave节点上的kubelet、kube-proxy,以及底层的网络支持(可以用Flannel、OpenVSwitch、Weave等)

      • API Server作为kubernetes系统的入口,封装了核心对象的增删改查操作,以RESTFul接口方式提供给外部客户和内部组件调用。它维护的REST对象将持久化到etcd(一个分布式强一致性的key/value存储)。
      • Scheduler:负责集群的资源调度,为新建的pod分配机器。这部分工作分出来变成一个组件,意味着可以很方便地替换成其他的调度器。
      • Controller Manager:负责执行各种控制器,目前有两类:(1)Endpoint Controller:定期关联service和pod(关联信息由endpoint对象维护),保证service到pod的映射总是最新的。(2)Replication Controller:定期关联replicationController和pod,保证replicationController定义的复制数量与实际运行pod的数量总是一致的。
    2. Node是运行节点,运行业务容器,包含以下组件:

      • Kubelet:责管控docker容器,如启动/停止、监控运行状态等。它会定期从etcd获取分配到本机的pod,并根据pod信息启动或停止相应的容器。同时,它也会接收apiserver的HTTP请求,汇报pod的运行状态。
      • Kube Proxy:负责为pod提供代理。它会定期从etcd获取所有的service,并根据service信息创建代理。当某个客户pod要访问其他pod时,访问请求会经过本机proxy做转发。

      Kubernets使用Etcd作为存储和通信中间件,实现Master和Node的一致性,这是目前比较常见的做法,典型的SOA架构,解耦Master和Node。

    3. 工作流

        上文已经提到了Kubernetes中最基本的三个操作对象:pod, replicationController及service。 下面分别从它们的对象创建出发,通过时序图来描述Kubernetes各个组件之间的交互及其工作流。

        

      alt

       


    4. Kubernetes的主要特性

      会从网络、服务发现、负载均衡、资源管理、高可用、存储、安全、监控等方面向大家简单介绍Kubernetes的这些主要特性 -> 由于时间有限,只能简单一些了。

      另外,对于服务发现、高可用和监控的一些更详细的介绍,感兴趣的朋友可以通过这篇文章了解。

      1)网络

      Kubernetes的网络方式主要解决以下几个问题:

      a. 紧耦合的容器之间通信,通过 Pod 和 localhost 访问解决。
      b. Pod之间通信,建立通信子网,比如隧道、路由,Flannel、Open vSwitch、Weave。
      c. Pod和Service,以及外部系统和Service的通信,引入Service解决。

      Kubernetes的网络会给每个Pod分配一个IP地址,不需要在Pod之间建立链接,也基本不需要去处理容器和主机之间的端口映射。

      注意:Pod重建后,IP会被重新分配,所以内网通信不要依赖Pod IP;通过Service环境变量或者DNS解决。

      2) 服务发现及负载均衡

      kube-proxy和DNS, 在v1之前,Service含有字段portalip 和publicIPs, 分别指定了服务的虚拟ip和服务的出口机ip,publicIPs可任意指定成集群中任意包含kube-proxy的节点,可多个。portalIp 通过NAT的方式跳转到container的内网地址。在v1版本中,publicIPS被约定废除,标记为deprecatedPublicIPs,仅用作向后兼容,portalIp也改为ClusterIp, 而在service port 定义列表里,增加了nodePort项,即对应node上映射的服务端口。

      DNS服务以addon的方式,需要安装skydns和kube2dns。kube2dns会通过读取Kubernetes API获取服务的clusterIP和port信息,同时以watch的方式检查service的变动,及时收集变动信息,并将对于的ip信息提交给etcd存档,而skydns通过etcd内的DNS记录信息,开启53端口对外提供服务。大概的DNS的域名记录是servicename.namespace.tenx.domain, "tenx.domain"是提前设置的主域名。

      注意:kube-proxy 在集群规模较大以后,可能会有访问的性能问题,可以考虑用其他方式替换,比如HAProxy,直接导流到Service 的endpints 或者 Pods上。Kubernetes官方也在修复这个问题。

      3)资源管理

      有3 个层次的资源限制方式,分别在Container、Pod、Namespace 层次。Container层次主要利用容器本身的支持,比如Docker 对CPU、内存、磁盘、网络等的支持;Pod方面可以限制系统内创建Pod的资源范围,比如最大或者最小的CPU、memory需求;Namespace层次就是对用户级别的资源限额了,包括CPU、内存,还可以限定Pod、rc、service的数量。

      资源管理模型 -》 简单、通用、准确,并可扩展

      目前的资源分配计算也相对简单,没有什么资源抢占之类的强大功能,通过每个节点上的资源总量、以及已经使用的各种资源加权和,来计算某个Pod优先非配到哪些节点,还没有加入对节点实际可用资源的评估,需要自己的scheduler plugin来支持。其实kubelet已经可以拿到节点的资源,只要进行收集计算即可,相信Kubernetes的后续版本会有支持。

      4)高可用

      主要是指Master节点的 HA方式 官方推荐 利用etcd实现master 选举,从多个Master中得到一个kube-apiserver 保证至少有一个master可用,实现high availability。对外以loadbalancer的方式提供入口。这种方式可以用作ha,但仍未成熟,据了解,未来会更新升级ha的功能。

      一张图帮助大家理解:
      pic2.png

      也就是在etcd集群背景下,存在多个kube-apiserver,并用pod-master保证仅是主master可用。同时kube-sheduller和kube-controller-manager也存在多个,而且伴随着kube-apiserver 同一时间只能有一套运行。

      5) rolling upgrade

      RC 在开始的设计就是让rolling upgrade变的更容易,通过一个一个替换Pod来更新service,实现服务中断时间的最小化。基本思路是创建一个复本为1的新的rc,并逐步减少老的rc的复本、增加新的rc的复本,在老的rc数量为0时将其删除。

      通过kubectl提供,可以指定更新的镜像、替换pod的时间间隔,也可以rollback 当前正在执行的upgrade操作。

      同样, Kuberntes也支持多版本同时部署,并通过lable来进行区分,在service不变的情况下,调整支撑服务的Pod,测试、监控新Pod的工作情况。
      pic3.png

      6)存储

      大家都知道容器本身一般不会对数据进行持久化处理,在Kubernetes中,容器异常退出,kubelet也只是简单的基于原有镜像重启一个新的容器。另外,如果我们在同一个Pod中运行多个容器,经常会需要在这些容器之间进行共享一些数据。Kuberenetes 的 Volume就是主要来解决上面两个基础问题的。

      Docker 也有Volume的概念,但是相对简单,而且目前的支持很有限,Kubernetes对Volume则有着清晰定义和广泛的支持。其中最核心的理念:Volume只是一个目录,并可以被在同一个Pod中的所有容器访问。而这个目录会是什么样,后端用什么介质和里面的内容则由使用的特定Volume类型决定。

      创建一个带Volume的Pod:
      pic4.png

      spec.volumes 指定这个Pod需要的volume信息 spec.containers.volumeMounts 指定哪些container需要用到这个Volume Kubernetes对Volume的支持非常广泛,有很多贡献者为其添加不同的存储支持,也反映出Kubernetes社区的活跃程度。
      • emptyDir 随Pod删除,适用于临时存储、灾难恢复、共享运行时数据,支持 RAM-backed filesystemhostPath 类似于Docker的本地Volume 用于访问一些本地资源(比如本地Docker)。
      • gcePersistentDisk GCE disk - 只有在 Google Cloud Engine 平台上可用。
      • awsElasticBlockStore 类似于GCE disk 节点必须是 AWS EC2的实例 nfs - 支持网络文件系统。
      • rbd - Rados Block Device - Ceph
      • secret 用来通过Kubernetes API 向Pod 传递敏感信息,使用 tmpfs (a RAM-backed filesystem)
      • persistentVolumeClaim - 从抽象的PV中申请资源,而无需关心存储的提供方
      • glusterfs
      • iscsi
      • gitRepo

      根据自己的需求选择合适的存储类型,反正支持的够多,总用一款适合的 :)

      7)安全

      一些主要原则:
      1. 基础设施模块应该通过API server交换数据、修改系统状态,而且只有API server可以访问后端存储(etcd)。
      2. 把用户分为不同的角色:Developers/Project Admins/Administrators。
      3. 允许Developers定义secrets 对象,并在pod启动时关联到相关容器。

      以secret 为例,如果kubelet要去pull 私有镜像,那么Kubernetes支持以下方式:
      1. 通过docker login 生成 .dockercfg 文件,进行全局授权。
      2. 通过在每个namespace上创建用户的secret对象,在创建Pod时指定 imagePullSecrets 属性(也可以统一设置在serviceAcouunt 上),进行授权。

      认证 (Authentication)
      API server 支持证书、token、和基本信息三种认证方式。

      授权 (Authorization)
      通过apiserver的安全端口,authorization会应用到所有http的请求上
      AlwaysDeny、AlwaysAllow、ABAC三种模式,其他需求可以自己实现Authorizer接口。

      8)监控

      比较老的版本Kubernetes需要外接cadvisor主要功能是将node主机的container metrics抓取出来。在较新的版本里,cadvior功能被集成到了kubelet组件中,kubelet在与docker交互的同时,对外提供监控服务。

      Kubernetes集群范围内的监控主要由kubelet、heapster和storage backend(如influxdb)构建。Heapster可以在集群范围获取metrics和事件数据。它可以以pod的方式运行在k8s平台里,也可以单独运行以standalone的方式。

      注意: heapster目前未到1.0版本,对于小规模的集群监控比较方便。但对于较大规模的集群,heapster目前的cache方式会吃掉大量内存。因为要定时获取整个集群的容器信息,信息在内存的临时存储成为问题,再加上heaspter要支持api获取临时metrics,如果将heapster以pod方式运行,很容易出现OOM。所以目前建议关掉cache并以standalone的方式独立出k8s平台。

    展开全文
  • 一、Kubernetes简介-是什么?

    万次阅读 多人点赞 2018-07-09 10:10:20
    Kubernetes 本文内容仅为个人理解,如有偏颇,欢迎指正。 一、传统的运维方式 在了解Kubernetes之前,我们有必要先简单了解一下传统的运维模式。在传统的项目架构中(单体or微服务),我们一般将项目打包为war或fat...

    Kubernetes

    本文内容仅为个人理解,如有偏颇,欢迎指正。

    一、传统的运维方式

    在了解Kubernetes之前,我们有必要先简单了解一下传统的运维模式。在传统的项目架构中(单体or微服务),我们一般将项目打包为war或fatJar的方式进行部署。

    在部署时,需要人工创建相应的服务器及资源,并搭建项目运行的依赖环境,预估服务需要占用的内存与CPU,同事还要考虑到高可用的部署环境,在不同配置的服务器上部署相应的服务。当服务意外崩溃或者服务器意外宕机时,需要人工处理。总结一下传统部署的不足如下:

    • 依赖服务器环境,需要各服务器资源统一。
    • 无法充分利用服务器等资源,使用率一般仅能达到70%。
    • 无法或很难做到容灾恢复。
    • 需要人工进行服务扩容,修改服务配置。
    • 服务资源散乱(域名,服务器,负载,数据库),无法做集中管理。
    • 时间消耗较多,增加运维成本。
    • 需要借助第三方工具进行资源监控,较为麻烦。
    • 需要对开发、测试、生产环境进行区别管理。

    要想解决以上的问题是相对比较麻烦的,特别是现在的项目多为微服务项目,少则几十,多则上百,极大的增加了运维的难度和成本。

    一、Kubernetes是什么?

    官方文档中描述为:v

    Kubernetes一个用于容器集群的自动化部署、扩容以及运维的开源平台。通过Kubernetes,你可以快速有效地响应用户需求;快速而有预期地部署你的应用;极速地扩展你的应用;无缝对接新应用功能;节省资源,优化硬件资源的使用。为容器编排管理提供了完整的开源方案。

    介绍一下其中提到的几个词:

    • 容器
      • 我们现在常说的容器一般是指Docker容器,通过容器隔离的特性和宿主机进行解耦,使我们的服务不需要依赖于宿主机而运行,与宿主机互不影响,Docker容器十分轻量。而kubernetes则负责管理服务中所有的Docker容器,创建、运行、重启与删除容器。
    • 快速响应
      • 个人理解为两个方面。一、新增或者修改需求时,可以快速进行部署测试(CICD);二、kubernetes可以根据不同条件进行动态扩缩容,举个栗子,用户访问量突然由1000人上升到100000人时,现有的服务已经无法支撑,kubernetes会自动将用户服务模块增加更多实例以保证当前的系统访问量。
    • 扩展
      • 在快速响应的特点中已经有所提及,这里再补充一点: Kubernetes内部有完善的注册发现机制,当某个服务的实例增加时,kubernetes会自动将其加入服务列表中,免除在传统运维中需要人工维护服务列表的问题。
    • 对接新应用
      • kubernetes是一个通用的容器编排框架,支持不同类型的语言,或者是语言无关的,新增加的应用都会以一个新的对象进行接入。
    • 硬件资源
      • 这一点我觉得是kubernetess很基本但是非常重要的一个优点了,kubernetes在部署应用时会自动检查各个服务器的cpu与内存使用量,同时会根据服务申请的cpu与内存资源,将服务部署到最合适的服务器。(其实这就是容器调度的核心功能了)

    小知识: 因kubernetes名字过长,一般简称为k8s,因为k与s之间有8个字母,故而称之。

    二、Kubernetes解决了什么问题?

    下面以几个case进行阐述,便于理解。

    服务器环境

    kubernetes是使用Docker进行容器管理的,所以天生具备Docker的所有特性,只需要使用相应环境的Docker镜像就可以运行服务,还需要关心宿主机是redhat、centos还是ubuntu,只要在宿主机上安装Docker环境即可,相比传统运维,减少了各种依赖环境的冲突,降低运维成本,也方便整体服务的迁移。

    服务器资源管理

    对于kubernetes来说,是不关心有几台服务器的,每个服务器都是一个资源对象(Node),kubernetes关心的是这个Node上有多少可用的cpu和内存。例如现在有两台服务器

    • server01 (4c16g), 已用(2c7.5G)
    • server02 (4c16g), 已用(3c13G)

    现在有一个服务ServiceA需要部署,ServiceA申明自己运行需要至少3G内存,这时kubernetes会根据调度策略将其部署到server01上,很明显server01的资源是更加充足的。实际上kubernetes的调度策略要复杂的多,kubernetes会监控整体服务器资源的状态进行调度,而以前的运维方式只能由人工判断资源使用。这里只做简单示例。

    各个服务器节点的状态

    这里写图片描述

    总体集群的资源状态

    这里写图片描述

    服务容灾恢复

    说简单点,就是服务挂了之后,能够自动恢复。例如现在有一个ServiceA,运行在server01上,kubernetes会通过内部的kubelet组件监控ServiceA服务进程的状态,一旦发现进程丢失(服务本身挂掉或者整个server01的服务器挂掉),就会尝试换一台资源充足的服务器重新部署ServiceA并启动,这样就可以确保我们的服务一直是可用状态,而不需要人工维护。

    硬件资源利用

    前面已经说过,kubernetes会根据节点(Node)的CPU与内存资源的可用量对服务进行部署调度,在调度策略中,可以配置不同的调度策略。例如现在有两台服务器:

    • server01 (4c16g), 已用(3c7.5G)
    • server02 (4c16g), 已用(1c13G)

    需要部署两个服务

    • serviceA-Java, 申请2G内存,0.5CPU单位
    • ServiceB-Nginx, 申请200M内存,申请1CPU单位

    这里kubernetes如果讲道理的话,会将ServiceA-Java部署到server01,将serviceB-Nginx部署到server02。这里server01的内存和server02的CPU资源都得到了充分的利用。经过个人实践,相比之前的部署方式,kubernetes节省了很多资源,资源利用是非常高效的。

    服务资源创建

    kubernetes创建服务是非常方便的,分为以下两个方面:

    • 自有服务
      • 在kubernetes中,进行项目服务部署是十分方便的,只需要构建好相应的镜像,编写一个yaml文件即可完成服务的部署。

    yaml示例

    apiVersion: apps/v1beta1
    kind: Deployment
    metadata:
      # 部署的模块名称
      name: phantom-server-admin
      # 需要部署哪个环境
      namespace: develop
    spec:
      # 部署的实例数量
      replicas: 1
      template: 
        metadata:
          labels:
            # 给这个部署打个标签,方便之后进行选择
            app: phantom-server-admin
        spec:
          containers:
          # 服务的名称
          - name: phantom-server-admin
            # 服务的镜像
            image: phantom-server-admin:v1
            ports:
            # 服务的端口
            - containerPort: 7006
            resources:
              limits:
                # 该服务需要的内存
                memory: 1000Mi
    • 公共基础服务
      • kubernetes开源社区中有一个工具叫helm, 类比的话就像是CentOS中的yum,我们可以通过这个工具进行简单快速的安装复杂的应用。阿里云提供了可视化的创建界面,创建十分方便,相比于传统运维需要自己进行基础软件的安装的优点是十分突出的,免去了繁琐的安装过程,服务的稳定性也有了一定的保障。talk is cheap, show you the below images,

    应用商店

    这里写图片描述

    eureka示例

    这里写图片描述

    可视化管理

    在kubernetes中,所有的概念都抽象成不同的对象,而所有的对象都是可以通过图形化界面进行管理和监控的,当然了,也同时提供了命令行客户端kubectl进行管理。

    对象创建

    这里写图片描述

    日志监控

    这里写图片描述

    服务资源监控

    各个节点的使用量监控

    这里写图片描述

    每个服务的使用量监控

    这里写图片描述

    资源整合管理

    在之前的运维过程中,对各种资源的管理是十分复杂的,想做到统一管理各种资源更是难上加难,从前到后,我们需要对域名、负载均衡、服务实例、存储服务进行逐个配置,配置的细节暂且不说,各个资源的关联关系就错综复杂,非专业运维人员是无法进行统一规划的。

    而使用与云服务整合的kubernetes之后,这些问题都迎刃而解。先看下图做简单说明

    这里写图片描述

    这是阿里kubernetes的路由配置界面,其中将负载均衡设备与域名和对应的服务进行了绑定,可以很直观的表述三者之间的关系,同时易于修改排错。

    版本管理与滚动升级

    • 版本管理

      • kubernetes在部署服务时,会记录部署服务的版本,我们可以很容易的进行上次版本或跨版本回退。
    • 滚动升级

      • kubernetes在进行服务升级时,采用的默认策略是先将一部分新的服务启动,确定服务正常后,停止一部分旧服务,进行新老服务的替换,之后再启动一些新的服务,停止一部分旧服务,直到旧服务全部停止,即切换完成。滚动省级的过程中,极大的减少了服务切换的间隔时间。

    其它

    上面所说的是kubernetes的主体功能,kubernetes还有很多其他重要的特性解决了之前运维的痛点,例如DNS解析、自动负载、存储声明等等。
    

    三、kubernetes特点

    网络模型

    kubernetes采用了三层网络模型,分为PodIP,ClusterIP,NodeIP。用简单的话来说,kubernetes在内部使用自己的网络进行通讯,这样做一个最直接的好处是我们不用再担心端口冲突的问题。

    举个栗子: 我们在server01上部署两个一样的服务serviceA-1,serviceA-2,两个服务的端口都是8080,这个时候有一个服务是无法启动的,因为端口被占用了,而在kubernetes中,两个服务在不同的Docker容器中,每个Docker容器都有自己的IP,这时就不会出现端口占用的问题了。

    为什么要有三层网络有三个IP呢?其实每个IP的作用是不一样的:

    • NodeIP
      • NodeIP是最好理解的,就是每个服务器的IP。例如server01的IP是192.168.1.2,有一个服务实例的IP申明类型为NodeIP,端口申明为30222,那么我们就可以通过192.168.1.2:30222访问到这个服务实例。
    • PodIP
      • PodIP的作用可以简单理解为每个服务自己teyoudeIP,就像上面说的可以解决端口冲突的问题,同时也是每个服务的唯一标识。PodIP是无法通过外网访问的,只能在服务内部进行访问。
    • ClusterIP(可以按照下面访问的进行理解,但实际有所区别)
      • 中文叫集群IP,对集群了解的同学应该很容易理解。集群IP可以简单理解为是对同一个服务的多个实例(每个实例有自己的PodIP)组成的集群的入口IP,换句话说,是对多个实例的负载IP。举个栗子:

    有三个实例:

    • serviceA-1 172.22.1.2
    • serviceA-2 172.22.1.3
    • serviceA-3 172.22.1.4

    有一个ClusterIP 172.23.2.23指向了serviceA服务,那么我们访问172.23.2.23则会负载转向到172.22.1.2、172.22.1.3、172.22.1.4中的其中一个服务

    对象

    在kubernetes中,万物皆对象。路由(Ingress)、服务(Service)、部署(Deployment)、存储(Storage/PV/PVC)、容器(Pod)、角色(Role)、账户(Accoutn)、配置(ConfigMap)等等。通过管理这些对象来管理整个kubernetes集群。

    注意:此处说的服务(Service),不同于上文提到的服务(开发的项目模块)

    声名式管理

    kubernetes采用声名式进行资源管理,也就是从结果来看问题。举个栗子,现在需要部署十个ServiceA

    面向过程: 部署ServiceA-01,再部署ServiceA02…..ServiceA-10,强调的是过程,用代码来表示的话就是while(serviceA.count < 10) {serviceA.count++}

    面向结果(声明式):不管是同时部署还是挨个部署,总之要部署十个ServiceA服务。用代码来表示的话就是kubernetes.addServiceA(10),不用管内部的细节怎么处理,只要最终的结果。

    

    四、Kubernetes常用相关概念

    部署 - Deployment

    类似于Docker中的镜像Image,也就是容器(Pods)实例的模板,容器实例是根据Deploy创建出来的。在Deployment对象中会写明容器的镜像,容器的版本,容器要部署的数量等信息。

    容器组 - Pods

    Pods是Kubernetes中的最小管理单元,Pods和Docker中的容器可以理解为包含关系,在Pods中可以包含有多个Docker容器,例如有ServiceA和ServiceB,ServiceA高度依赖ServiceB(需要共享主机的相同文件),这时就可以将ServiceA与ServiceB放在同一个Pods中,当做一个整体来管理。如果分开部署当然也可以,不过会小号额外的资源或者产生其他不必要的麻烦。

    服务 - Service

    Service是一个对象,这个对象有自己的IP,也就是ClusterIP,可以理解为就是下层服务的负载均衡。

    路由 - Ingress

    无论是容器组还是Service,外网都是无法直接访问的,Ingress就可以通过一个负载IP与Kubernetes集群内部进行通讯,一般会和Service对象进行配合使用。

    配置项 - ConfigMap

    简单理解为一个管理配置的对象,可以将项目的配置写入到ConfgiMap中,项目中的配置使用相应的变量名就可以读取相应的变量值。

    还有很多其它概念,这是就不一一介绍了,可以参考Kubernetes中文社区

    五、Kubernetes结构图

    Kubernetes由Master节点和Worker节点组成。master节点是Kubernetes的大脑,而woker节点则是kubernetes中实际运行服务的劳动者。

    Master主要由ETCD/Controller Manager/Api Server/Schedular能成,

    • ETCD
      • 主要负责存储各个woker节点的状态和其它相关数据,可以理解为kubernetes的数据库。
    • Controller Manager
      • 负责维护集群的状态,比如故障检测、自动扩展、滚动更新等
    • Scheduler
      • 负责资源的调度,按照预定的调度策略将Pod调度到相应的机器上

    Worker主要由kubelet和kube-proxy组成,一般还会安装kube-dns组件。

    • kubelet
      • 负责维护容器的生命周期,同时也负责Volume(CVI)和网络(CNI)的管理;
    • kube-proxy
      • 负责为Service提供cluster内部的服务发现和负载均衡;
    • kube-dns
      • 负责为整个集群提供DNS服务,通过Service名称访问相应的服务

    这里写图片描述

    六、总结

    Kubernetes在容器编排可谓是做到了淋漓尽致,解决了之前的种种痛点,但是学习成本也相对较高,需要结合一定的实践,踩一定的坑才能形成自己的理解。

    Thanks !

    展开全文
  • 除了已经拥抱Kubernetes的Google、BAT、京东、奇虎360等巨头大厂外,更多的企业也都在向Kubernetes迁移。容器技术大势所趋,是互联网企业目前急需的技术人才之一,已成为运维工程师、架构师的必备技能之一。机会总是...
  • 本课程主要面向一线的开发和运维人员,帮助开发和运维掌握 Kubernetes的配置、部署、使用和维护,了解 Kubernetes的架构,了解如何扩展 KubernetesKubernetes与Docker的使用。 预备知识: 1. 熟悉 Linux 的操作 ...
  • Kubernetes 最新版本安装过程和注意事项

    万次阅读 多人点赞 2019-08-13 21:56:35
    在 18 年 6 月份京东活动的时候,买了一本 Kubernetes 权威指南,一直没时间看,春节期间正好学学。由于书上使用的是 2017 年的 1.6.0 版本,我自己为了使用最新版本,特地做一个记录。 虽然买了本书,但是整个操作...

    本文写于 2019-02-06 已亥猪年 农历正月初二
    当前最新版本为 v1.13.3

    在 18 年 6 月份京东活动的时候,买了一本 Kubernetes 权威指南,一直没时间看,春节期间正好学学。由于书上使用的是 2017 年的 1.6.0 版本,我自己为了使用最新版本,特地做一个记录。

    虽然买了本书,但是整个操作过程参考了很多资料,主要是 kubeadm 官方文档:

    系统防火墙配置
    禁用防火墙
    systemctl disable firewalld
    关闭防火墙
    systemctl stop firewalld
    禁用 SELinux,目的是让容器可以读取主机文件系统
    setenforce 0
    配置禁用 SELinux
    vi /etc/sysconfig/selinux
    修改 SELINUX 为 disabled
    SELINUX=disabled
    #SELINUX=enforcing

    在上述第一个文档中安装 kubeadm,kubelet 和 kubectl 这一步时,文档提供的脚本中的地址都是https://packages.cloud.google.com 域名下的,由于被墙无法使用,我们可以使用阿里巴巴开源镜像站 提供的 kubernetes。

    1. 安装 kubelet kubeadm kubectl

    使用阿里巴巴开源镜像站

    https://opsx.alibaba.com/mirror

    从列表找到 kubernetes,点击帮助,显示如下信息。

    我使用的最新版本的 CentOS 7:VMware 虚拟机 最小化安装 CentOS 7 的 IP 配置

    Debian / Ubuntu

    apt-get update && apt-get install -y apt-transport-https
    curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add - 
    cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
    deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
    EOF  
    apt-get update
    apt-get install -y kubelet kubeadm kubectl
    

    CentOS / RHEL / Fedora

    cat <<EOF > /etc/yum.repos.d/kubernetes.repo
    [kubernetes]
    name=Kubernetes
    baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
    enabled=1
    gpgcheck=1
    repo_gpgcheck=1
    gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
    EOF
    setenforce 0
    yum install -y kubelet kubeadm kubectl
    systemctl enable kubelet && systemctl start kubelet
    

    Docker CE

    阿里巴巴开源镜像站还可以搜 docker-ce,帮助中给了一个地址:

    https://yq.aliyun.com/articles/110806

    特别注意:本文的 Kubernetes 版本为 v1.13.3,因为我使用 docker 官方脚本安装的最新版本的,所以执行 kubeadm init 时有下面的警告:

    [WARNING SystemVerification]: this Docker version is not on the list of validated versions: 18.09.0. Latest validated version: 18.06

    因此使用 18.06 版本可以消除该警告,如果要指定版本,上面文档中也有说明。

    关闭防火墙
    查看防火墙状态: firewall-cmd --state
    关闭防火墙: systemctl stop firewalld.service
    禁止开机启动:systemctl disable firewalld.service
    参考:https://www.linuxidc.com/Linux/2016-12/138979.htm

    2. Docker 加速

    由于国内下载 docker image 速度较慢,可以使用镜像进行加速。

    编辑或新增 /etc/docker/daemon.json 添加如下内容:

    {
      "registry-mirrors": [
        "https://dockerhub.azk8s.cn",
        "https://reg-mirror.qiniu.com"
      ]
    }
    

    参考:https://yeasy.gitbooks.io/docker_practice/install/mirror.html

    3. 执行 kubeadm init

    执行该命令时会出现很多问题,这里都列举出来。

    执行 kubeadm init 时,会先请求 https://dl.k8s.io/release/stable-1.txt 获取最新稳定的版本号,该地址实际会跳转到 https://storage.googleapis.com/kubernetes-release/release/stable-1.txt ,在写本文时此时的返回值为 v1.13.3。由于被墙无法请求该地址,为了避免这个问题,我们可以直接指定要获取的版本,执行下面的命令:

    kubeadm init --kubernetes-version=v1.13.3
    

    执行该命令时可能会遇到下面的错误。

    3.1 ERROR FileContent–proc-sys-net-bridge-bridge-nf-call-iptables

    问题:

    [ERROR FileContent--proc-sys-net-bridge-bridge-nf-call-iptables]: /proc/sys/net/bridge/bridge-nf-call-iptables contents are not set to 1
    

    解决方案:

    echo 1 > /proc/sys/net/bridge/bridge-nf-call-iptables
    echo 1 > /proc/sys/net/bridge/bridge-nf-call-ip6tables
    

    3.2 ERROR Swap

    问题:

    [ERROR Swap]: running with swap on is not supported. Please disable swap
    

    解决方案,禁用 swap 分区:

    #禁用当前的 swap
    sudo swapoff -a 
    #同时永久禁掉swap分区,打开如下文件注释掉swap那一行
    sudo vi /etc/fstab
    

    3.3 无法下载镜像

    问题(有删减):

    error execution phase preflight: [preflight] Some fatal errors occurred:
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-apiserver:v1.13.3
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-controller-manager:v1.13.3
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-scheduler:v1.13.3
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-proxy:v1.13.3
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/pause:3.1
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/etcd:3.2.24
    	[ERROR ImagePull]: failed to pull image k8s.gcr.io/coredns:1.2.6
    

    由于 gcr.io 被墙无法下载,我们可以先通过其他渠道下载,然后在继续执行命令。

    4. 预先下载镜像

    根据前面错误信息来看我们需要下载的镜像。就当前来说,用户 mirrorgooglecontainers 在 docker hub 同步了所有 k8s 最新的镜像,先从这儿下载,然后修改 tag 即可。

    docker pull mirrorgooglecontainers/kube-apiserver:v1.13.3
    docker pull mirrorgooglecontainers/kube-controller-manager:v1.13.3
    docker pull mirrorgooglecontainers/kube-scheduler:v1.13.3
    docker pull mirrorgooglecontainers/kube-proxy:v1.13.3
    docker pull mirrorgooglecontainers/pause:3.1
    docker pull mirrorgooglecontainers/etcd:3.2.24
    docker pull coredns/coredns:1.2.6
    

    下载完成后,通过 docker images 查看如下:

    REPOSITORY                                       TAG                 IMAGE ID            CREATED             SIZE
    mirrorgooglecontainers/kube-apiserver            v1.13.3             fe242e556a99        5 days ago          181MB
    mirrorgooglecontainers/kube-controller-manager   v1.13.3             0482f6400933        5 days ago          146MB
    mirrorgooglecontainers/kube-proxy                v1.13.3             98db19758ad4        5 days ago          80.3MB
    mirrorgooglecontainers/kube-scheduler            v1.13.3             3a6f709e97a0        5 days ago          79.6MB
    coredns/coredns                                  1.2.6               f59dcacceff4        3 months ago        40MB
    mirrorgooglecontainers/etcd                      3.2.24              3cab8e1b9802        4 months ago        220MB
    mirrorgooglecontainers/pause                     3.1                 da86e6ba6ca1        13 months ago       742kB
    

    分别修改上述镜像的标签。

    docker tag mirrorgooglecontainers/kube-apiserver:v1.13.3 k8s.gcr.io/kube-apiserver:v1.13.3
    docker tag mirrorgooglecontainers/kube-controller-manager:v1.13.3 k8s.gcr.io/kube-controller-manager:v1.13.3
    docker tag mirrorgooglecontainers/kube-scheduler:v1.13.3 k8s.gcr.io/kube-scheduler:v1.13.3
    docker tag mirrorgooglecontainers/kube-proxy:v1.13.3 k8s.gcr.io/kube-proxy:v1.13.3
    docker tag mirrorgooglecontainers/pause:3.1 k8s.gcr.io/pause:3.1
    docker tag mirrorgooglecontainers/etcd:3.2.24 k8s.gcr.io/etcd:3.2.24
    docker tag coredns/coredns:1.2.6 k8s.gcr.io/coredns:1.2.6
    

    配置好镜像后继续执行前面的命令:

    kubeadm init --kubernetes-version=v1.13.3
    

    5. 安装成功

    前面命令执行输出的日志如下(保存好这段日志):

    [root@k8s-master ~]# kubeadm init --kubernetes-version=v1.13.3
    [init] Using Kubernetes version: v1.13.3
    [preflight] Running pre-flight checks
    	[WARNING SystemVerification]: this Docker version is not on the list of validated versions: 18.09.0. Latest validated version: 18.06
    [preflight] Pulling images required for setting up a Kubernetes cluster
    [preflight] This might take a minute or two, depending on the speed of your internet connection
    [preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
    [kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
    [kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
    [kubelet-start] Activating the kubelet service
    [certs] Using certificateDir folder "/etc/kubernetes/pki"
    [certs] Generating "etcd/ca" certificate and key
    [certs] Generating "etcd/peer" certificate and key
    [certs] etcd/peer serving cert is signed for DNS names [k8s-master localhost] and IPs [192.168.200.131 127.0.0.1 ::1]
    [certs] Generating "etcd/healthcheck-client" certificate and key
    [certs] Generating "etcd/server" certificate and key
    [certs] etcd/server serving cert is signed for DNS names [k8s-master localhost] and IPs [192.168.200.131 127.0.0.1 ::1]
    [certs] Generating "apiserver-etcd-client" certificate and key
    [certs] Generating "ca" certificate and key
    [certs] Generating "apiserver" certificate and key
    [certs] apiserver serving cert is signed for DNS names [k8s-master kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 192.168.200.131]
    [certs] Generating "apiserver-kubelet-client" certificate and key
    [certs] Generating "front-proxy-ca" certificate and key
    [certs] Generating "front-proxy-client" certificate and key
    [certs] Generating "sa" key and public key
    [kubeconfig] Using kubeconfig folder "/etc/kubernetes"
    [kubeconfig] Writing "admin.conf" kubeconfig file
    [kubeconfig] Writing "kubelet.conf" kubeconfig file
    [kubeconfig] Writing "controller-manager.conf" kubeconfig file
    [kubeconfig] Writing "scheduler.conf" kubeconfig file
    [control-plane] Using manifest folder "/etc/kubernetes/manifests"
    [control-plane] Creating static Pod manifest for "kube-apiserver"
    [control-plane] Creating static Pod manifest for "kube-controller-manager"
    [control-plane] Creating static Pod manifest for "kube-scheduler"
    [etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
    [wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
    [apiclient] All control plane components are healthy after 21.507393 seconds
    [uploadconfig] storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
    [kubelet] Creating a ConfigMap "kubelet-config-1.13" in namespace kube-system with the configuration for the kubelets in the cluster
    [patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "k8s-master" as an annotation
    [mark-control-plane] Marking the node k8s-master as control-plane by adding the label "node-role.kubernetes.io/master=''"
    [mark-control-plane] Marking the node k8s-master as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
    [bootstrap-token] Using token: 7j01ut.pbdh60q732m1kd4v
    [bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
    [bootstraptoken] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
    [bootstraptoken] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
    [bootstraptoken] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
    [bootstraptoken] creating the "cluster-info" ConfigMap in the "kube-public" namespace
    [addons] Applied essential addon: CoreDNS
    [addons] Applied essential addon: kube-proxy
    
    Your Kubernetes master has initialized successfully!
    
    To start using your cluster, you need to run the following as a regular user:
    
      mkdir -p $HOME/.kube
      sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
      sudo chown $(id -u):$(id -g) $HOME/.kube/config
    
    You should now deploy a pod network to the cluster.
    Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
      https://kubernetes.io/docs/concepts/cluster-administration/addons/
    
    You can now join any number of machines by running the following on each node
    as root:
    
      kubeadm join 192.168.200.131:6443 --token 7j01ut.pbdh60q732m1kd4v --discovery-token-ca-cert-hash sha256:de1dc033ae5cc27607b0f271655dd884c0bf6efb458957133dd9f50681fa2723
    
    

    6. 特别注意上面提示的后续操作(一)

    上面要求执行下面的操作:

    mkdir -p $HOME/.kube
    sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
    sudo chown $(id -u):$(id -g) $HOME/.kube/config
    

    有了上面配置后,后续才能使用 kubectl 执行命令。

    如果你系统重启过,执行 kubectl 时你可能会遇到类似下面这样的问题:

    [root@k8s-master ~]# kubectl get pods
    The connection to the server 192.168.200.131:6443 was refused - did you specify the right host or port?
    

    我不清楚这里具体的原因,但是找到了问题的根源就是 swap,在前面 3.2 中,如果没有彻底禁用 swap,重启后会仍然启用,此时的 k8s 就会出现上面的错误。因为这个原因,所以建议直接禁用:

    #永久禁掉swap分区,打开如下文件注释掉swap那一行
    sudo vi /etc/fstab
    

    7. 特别注意上面提示的后续操作(二)

    上面要求执行下面的操作:

    You should now deploy a pod network to the cluster.
    Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
      https://kubernetes.io/docs/concepts/cluster-administration/addons/
    

    参考Kubernetes 权威指南(书上用的 v1.6),这里安装 Weave 插件,文档地址:

    https://www.weave.works/docs/net/latest/kubernetes/kube-addon/

    按照文档,执行下面的命令:

    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
    

    输出的内容如下:

    serviceaccount/weave-net created
    clusterrole.rbac.authorization.k8s.io/weave-net created
    clusterrolebinding.rbac.authorization.k8s.io/weave-net created
    role.rbac.authorization.k8s.io/weave-net created
    rolebinding.rbac.authorization.k8s.io/weave-net created
    daemonset.extensions/weave-net created
    

    8. 特别注意上面提示的后续操作(三)

    上面要求在NODE节点的主机上,以 root 用户执行下面的操作,

    kubeadm join 192.168.200.131:6443 --token 7j01ut.pbdh60q732m1kd4v --discovery-token-ca-cert-hash sha256:de1dc033ae5cc27607b0f271655dd884c0bf6efb458957133dd9f50681fa2723
    

    注意,别复制这里的,看你自己上面安装后输出的内容。
    这段代码中的 token 可能存在有效期 1 天,如果过期,可以参考下面地址获取最新的 token
    https://kubernetes.io/docs/setup/independent/create-cluster-kubeadm/#join-nodes

    如果你使用的多个主机组建的集群,可以在其他主机执行上面的命令加入到集群中。

    因为我这儿是实验用,所以我用的单机集群方式。

    9. 单机集群

    参考官方文档:https://kubernetes.io/docs/setup/independent/create-cluster-kubeadm/

    先执行下面的命令查看当前 pods 状态:

    [root@k8s-master ~]# kubectl get pods --all-namespaces
    NAMESPACE     NAME                                 READY   STATUS    RESTARTS   AGE
    kube-system   coredns-86c58d9df4-9s65p             0/1     Error     0          59m
    kube-system   coredns-86c58d9df4-dvg7b             0/1     Error     0          59m
    kube-system   etcd-k8s-master                      1/1     Running   3          58m
    kube-system   kube-apiserver-k8s-master            1/1     Running   3          58m
    kube-system   kube-controller-manager-k8s-master   1/1     Running   3          58m
    kube-system   kube-proxy-5p4d8                     1/1     Running   3          59m
    kube-system   kube-scheduler-k8s-master            1/1     Running   3          58m
    kube-system   weave-net-j87km                      1/2     Running   2          16m
    

    此时看到两个 Error,不清楚原因,然后执行单机集群的命令:

    kubectl taint nodes --all node-role.kubernetes.io/master-
    

    再次查看状态:

    [root@k8s-master ~]# kubectl get pods --all-namespaces
    NAMESPACE     NAME                                 READY   STATUS    RESTARTS   AGE
    kube-system   coredns-86c58d9df4-9s65p             1/1     Running   1          60m
    kube-system   coredns-86c58d9df4-dvg7b             1/1     Running   1          60m
    kube-system   etcd-k8s-master                      1/1     Running   3          59m
    kube-system   kube-apiserver-k8s-master            1/1     Running   3          59m
    kube-system   kube-controller-manager-k8s-master   1/1     Running   3          59m
    kube-system   kube-proxy-5p4d8                     1/1     Running   3          60m
    kube-system   kube-scheduler-k8s-master            1/1     Running   3          59m
    kube-system   weave-net-j87km                      2/2     Running   3          16m
    

    现在都正常了。

    退出系统,创建快照(在本文操作过程中,我创建了 3 个不同阶段的快照)。

    10. 虚拟机备份下载

    为了方便自己和他人使用,提供一个虚拟机的备份方便直接使用(如果安装遇到各种莫名其妙错误想要直接跳过安装的)。

    虚拟机版本:15.0.0 build-10134415
    虚拟机备份链接: https://pan.baidu.com/s/1s3FZtcvONgFXAmz1AUU9_w
    提取码: tbi2

    系统登陆用户:root
    系统登陆密码:jj
    有关虚拟机的 IP 信息看这里:VMware 虚拟机 最小化安装 CentOS 7 的 IP 配置

    如果想要修改 IP 应该怎么做?

    1. 首先改 IP,重启 network 服务。
    2. 重置 k8s,执行 kubeadm reset
    3. 执行安装 kubeadm init --kubernetes-version=v1.13.3
    4. 你可能还会遇到 3.1 中的问题,按照上面配置即可。
    5. 先删除6中创建的 $HOME/.kube 目录,执行 rm -rf $HOME/.kube
    6. 执行 6. 特别注意上面提示的后续操作(一) 中的操作。
    7. 执行7. 特别注意上面提示的后续操作(二) 中的操作。
    8. 如果是单机集群方式,还需执行kubectl taint nodes --all node-role.kubernetes.io/master-
    9. 好了,又满血复活了,执行 kubectl get pods --all-namespaces 查看状态。

    11. 小结

    本文是一边写一边操作验证写完的,写完的时候,我自己的配置都没问题了,从头下来虽然花的时间比较长,但是还算顺利,本文只是配置了 Kubernetes 的实验环境,一切才刚刚开始!

    12. 补充常见问题

    根据我自己后续操作遇到的问题,都列举在此。

    12.1 Pod 一直是 Pending

    例如:

    [root@k8s-master chapter01]# kubectl get pods
    NAME          READY   STATUS    RESTARTS   AGE
    mysql-4wvzz   0/1     Pending   0          4m1s
    

    此时可以通过下面命令查看 Pod 状态:

    [root@k8s-master chapter01]# kubectl describe pods mysql-4wvzz
    Name:               mysql-4wvzz
    Namespace:          default
    Priority:           0
    PriorityClassName:  <none>
    Node:               <none>
    Labels:             app=mysql
    Annotations:        <none>
    Status:             Pending
    IP:                 
    Controlled By:      ReplicationController/mysql
    Containers:
      mysql:
        Image:      mysql
        Port:       3306/TCP
        Host Port:  0/TCP
        Environment:
          MYSQL_ROOT_PASSWORD:  123456
        Mounts:
          /var/run/secrets/kubernetes.io/serviceaccount from default-token-rksdn (ro)
    Conditions:
      Type           Status
      PodScheduled   False 
    Volumes:
      default-token-rksdn:
        Type:        Secret (a volume populated by a Secret)
        SecretName:  default-token-rksdn
        Optional:    false
    QoS Class:       BestEffort
    Node-Selectors:  <none>
    Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                     node.kubernetes.io/unreachable:NoExecute for 300s
    Events:
      Type     Reason            Age                 From               Message
      ----     ------            ----                ----               -------
      Warning  FailedScheduling  28s (x3 over 103s)  default-scheduler  0/1 nodes are available: 1 node(s) had taints that the pod didn't tolerate.
    
    

    此时发现一个警告:0/1 nodes are available: 1 node(s) had taints that the pod didn’t tolerate.

    该问题是因为没有可用的节点NODE,所以无法部署,如果你使用的单机集群方式,你可能是忘了执行下面的命令:

    kubectl taint nodes --all node-role.kubernetes.io/master-
    

    如果是多机集群,通过 kubectl get nodes 查看节点状态,保证有可用节点。

    问题解决后,再次查看 Pod 状态,此时的事件部分输出如下:

    Events:
      Type     Reason            Age                 From                 Message
      ----     ------            ----                ----                 -------
      Warning  FailedScheduling  51s (x9 over 6m6s)  default-scheduler    0/1 nodes are available: 1 node(s) had taints that the pod didn't tolerate.
      Normal   Scheduled         10s                 default-scheduler    Successfully assigned default/mysql-4wvzz to k8s-master
      Normal   Pulling           9s                  kubelet, k8s-master  pulling image "mysql"
      Normal   Pulled            7s                  kubelet, k8s-master  Successfully pulled image "mysql"
      Normal   Created           7s                  kubelet, k8s-master  Created container
      Normal   Started           7s                  kubelet, k8s-master  Started container
    

    此时问题已经解决。

    12.2 weave cni 无效,改用 flannel

    展开全文
  • kubernetes

    2020-07-30 23:30:14
    kubernetes 学习参考资料,很好学习参考资料,很好学习参考资料,很好
  • Kubernetes入门(一)

    千次阅读 2019-11-06 14:50:02
    Kubernetes也叫做k8s。它是一个开源系统,主要用于自动部署、扩容缩容和管理容器化应用。它将诸多应用的容器分为若干个逻辑单元以便于管理和发现。kubernetes拥有着Google高负载生产环境的15年经验,并结合了社区的...

    Kubernetes也叫做k8s。它是一个开源系统,主要用于自动部署、扩容缩容和管理容器化应用。它将诸多应用的容器分为若干个逻辑单元以便于管理和发现。kubernetes拥有着Google高负载生产环境的15年经验,并结合了社区的优秀思想和实践。


    30.1 Kubernetes介绍


    Kubernetes官网:https://kubernetes.io/

    在Kubernetes中,service是核心,我们并不需要太多关心kubernetes里面是怎么工作的,我们只需要关心它给我们提供什么service。就像docker容器可以提供一个mysqld的服务、web服务等。

    它需要拥有一个唯一的名字、以及ip:port来对外提供服务。提供service的是容器,为了保证service的高可用,提供service的容器不能只有一个,需要一组,这一组容器我们把它叫做pod。pod是kubernetes最基本的操作单元。

    为了实现service和pod之间的管理,又有了标签(label)的概念,我们把功能相同的pod设定为同一个标签。比如,可以把所有提供mysql服务的pod打上标签name=mysql,这样mysql service要作用于所有包含name=mysql标签的pod上。

    pod运行在Node上,Node可以是一台物理机,也可以是虚拟机。通常一个Node上会运行几百个pod,每个pod里运行着一个特殊的容器,叫做Pause,其它容器叫做业务容器,业务容器共享Pause容器的网络栈和Volume挂载卷,因此同一个pod内的业务容器之间的通信和数据交换更为高效。

    在集群管理方面,kubernetes将集群中的机器划分为一个Master节点和一群工作节点Node,其中Master上运行着kube-apiserver、kube-controller-manager、kube-scheduler,他们实现了资源管理、pod调度、弹性伸缩、安全控制、系统监控、纠错等功能。Node是工作节点,运行应用程序,提供服务。Node上的最小单元是pod,Node上运行着kubernetesd的kubelet、kube-proxy服务进程,它们负责pod的创建、启动、监控、重启、销毁,已经实现负载均衡。

    扩容和升级需要一个关键的东西,Replication controller(RC),RC需要包含3个关键信息:

    1)目标pod的定义
    
    2)目标pod需要运行的副本数量(replicas)
    
    3)要监控的目标pod的标签(Label)
    

    工作过程:RC里需要定义好3个指标,kubernetes会根据RC定义的Label筛选出对应的pod,并实时监控其状态和数量,当实例数量少于定义的副本数(replicas)时,则会根据RC定义的pod模板来创建新的pod,然后将此pod调度到合适的Node上启动并运行。整个过程完全自动化,无需人工干涉。


    30.2 示例


    下面从一个例子开始:webapp + mysql 。准备一台centos7机器。

    • 关闭firewalld和selinux:
    # systemctl stop firewalld && systemctl disable firewalld
    
    # setenforce 0
    
    • 安装etcd和kubernetes:
    # yum install -y etcd kubernetes
    
    • 修改配置文件:
    # vim /etc/sysconfig/docker
    将   --selinux-enabled   改为   --selinux-enabled=false --insecure-registry gcr.io
    
    # vim /etc/kubernetes/apiserver
    将  KUBE_ADMISSION_CONTROL  参数中的  ServiceAccount  删除
    
    • 准备工作:
    # yum install -y python-rhsm-certificates
    
    如果提示:Package python-rhsm-certificates-1.19.10-1.el7_4.x86_64 is obsoleted by subscription-manager-rhsm-certificates-1.21.10-3.el7.centos.x86_64 which is already installed ,
    则执行下面步骤,否则不执行
    
    # 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 > /etc/rhsm/ca/redhat-uep.pem
    
    • 配置docker加速器:
    # vim /etc/docker/daemon.json 
    {
      "registry-mirrors": ["https://dhq9bx4f.mirror.aliyuncs.com"]
    }
    
    • 按顺序启动所有服务:
    # for s in etcd docker kube-apiserver kube-controller-manager kube-scheduler kubelet kube-proxy; do systemctl start $s; done
    
    • 创建一个rc文件:
    # 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                     
              value: "123456"
    
    # docker pull registry.access.redhat.com/rhel7/pod-infrastructure:latest
    
    # docker pull mysql:5.6
    
    # kubectl create -f mysql.rc.yaml               #创建pod。上面两步可省略,若提前拉取镜像则该步执行更快
    replicationcontroller "mysql" created
    
    # kubectl get pod
    NAME          READY     STATUS              RESTARTS   AGE
    mysql-f16r2   0/1       ContainerCreating   0          1m                   #容器正在创建中
    
    # kubectl get pod
    NAME          READY     STATUS    RESTARTS   AGE
    mysql-f16r2   1/1       Running   0          3m                 #已经启动
    
    • 创建一个svc文件:
    # vim mysql-svc.yaml
    
    apiVersion: v1
    kind: Service
    metadata:
      name: mysql
    spec:
      ports:
        - port: 3306
      selector:
        app: mysql
    
    # kubectl create -f mysql-svc.yaml              #创建service
    service "mysql" created
    
    # kubectl get svc
    NAME         CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
    kubernetes   10.254.0.1       <none>        443/TCP    58m
    mysql        10.254.218.177   <none>        3306/TCP   33s
    
    # yum install -y mysql
    
    # mysql -uroot -p123456 -h10.254.218.177              #此时就可以直接访问这个mysql服务
    MySQL [(none)]> show databases;
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | mysql              |
    | performance_schema |
    +--------------------+
    3 rows in set (0.01 sec)
    
    • 创建web的rc文件:
    # 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.218.177'                 #如果已经搭建kube-dns服务,此处可直接填mysql即可
              - name: MYSQL_SERVICE_PORT
                value: '3306'
    
    # kubectl create -f myweb-rc.yaml
    replicationcontroller "myweb" created
    
    # kubectl get pod
    NAME          READY     STATUS              RESTARTS   AGE
    mysql-f16r2   1/1       Running             0          20m
    myweb-f8xw9   0/1       ContainerCreating   0          8s                   #正在创建中
    
    # kubectl get pod
    NAME          READY     STATUS    RESTARTS   AGE
    mysql-f16r2   1/1       Running   0          23m
    myweb-f8xw9   1/1       Running   0          3m
    
    • 创建web的svc文件:
    # vim myweb-svc.yaml
    
    kind: Service
    metadata:
      name: myweb
    spec:
      type: NodePort
      ports:
        - port: 8080
          nodePort: 30001              #通过Node ip访问,映射到Node上的这个端口
      selector:
        app: myweb
    
    # kubectl create -f myweb-svc.yaml 
    service "myweb" created
    
    # kubectl get svc
    NAME         CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
    kubernetes   10.254.0.1       <none>        443/TCP          1h
    mysql        10.254.218.177   <none>        3306/TCP         26m
    myweb        10.254.171.116   <nodes>       8080:30001/TCP   1m
    
    # curl 10.254.171.116:8080/damo/
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>HPE University Docker&Kubernetes Learning</title>
    </head>
    <body  align="center">
    
    	
          <h2>Congratulations!!</h2>
         <br></br>
    	 <input type="button" value="Add..." onclick="location.href='input.html'" >
    	     <br></br>
          <TABLE align="center"  border="1" width="600px">
       <TR>
          <TD>Name</TD>
          <TD>Level(Score)</TD>
       </TR>
    
          
     <TR>
          <TD>google</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>docker</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>teacher</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>HPE</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>our team</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>me</TD>
          <TD>100</TD>
       </TR>
    
      </TABLE>
          
    </body>
    </html>
    
    # curl 192.168.30.128:30001/demo/               #可以看到,通过本机ip的30001端口也可以访问到相同的数据
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>HPE University Docker&Kubernetes Learning</title>
    </head>
    <body  align="center">
    
    	
          <h2>Congratulations!!</h2>
         <br></br>
    	 <input type="button" value="Add..." onclick="location.href='input.html'" >
    	     <br></br>
          <TABLE align="center"  border="1" width="600px">
       <TR>
          <TD>Name</TD>
          <TD>Level(Score)</TD>
       </TR>
    
          
     <TR>
          <TD>google</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>docker</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>teacher</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>HPE</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>our team</TD>
          <TD>100</TD>
       </TR>
    
     <TR>
          <TD>me</TD>
          <TD>100</TD>
       </TR>
    
      </TABLE>
          
    </body>
    </html>
    
    • 通过浏览器访问:
    # iptables -P FORWARD ACCEPT
    

    在这里插入图片描述

    新增一条记录

    在这里插入图片描述

    在这里插入图片描述

    再到mysql数据库查看

    # mysql -uroot -p123456 -h10.254.218.177
    MySQL [(none)]> show databases;
    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | HPE_APP            |
    | mysql              |
    | performance_schema |
    +--------------------+
    4 rows in set (0.01 sec)
    
    MySQL [(none)]> use HPE_APP;
    Reading table information for completion of table and column names
    You can turn off this feature to get a quicker startup with -A
    
    Database changed
    MySQL [HPE_APP]> show tables;
    +-------------------+
    | Tables_in_HPE_APP |
    +-------------------+
    | T_USERS           |
    +-------------------+
    1 row in set (0.00 sec)
    
    MySQL [HPE_APP]> select * from T_USERS;
    +----+-----------+-------+
    | ID | USER_NAME | LEVEL |
    +----+-----------+-------+
    |  1 | me        | 100   |
    |  2 | our team  | 100   |
    |  3 | HPE       | 100   |
    |  4 | teacher   | 100   |
    |  5 | docker    | 100   |
    |  6 | google    | 100   |
    |  7 | lzx       | 100   |
    +----+-----------+-------+
    7 rows in set (0.00 sec)
    

    可以看到,有刚刚新增的lzx记录。


    展开全文
  • 1、Kubernetes是什么 Kubernetes是一个轻便的和可扩展的开源平台,用于管理容器化应用和服务。通过Kubernetes能够进行应用的自动化部署和扩缩容。在Kubernetes中,会将组成应用的容器组合成一个逻辑单元以更易管理...
  • 本文主要介绍了kubernetes涉及的相关组件以及一些基本概念的介绍。从部署搭建以及运行的角度说明了底层docker以及数据存储相关的etcd的一些基础知识以及涉及的相关合核心内容,让读者针对k8s有一个大致的了解。
  • K8S基础 K8S基础架构 K8S解决的问题是什么? k8s全景图 k8s Secret对象 声明式API K8S基础架构 基础架构图如下所示,我们可以看到master 节点和Node节点。 Master节点是控制节点,由三个紧密协作的独立组件组合而成...
  • kubernetes 集群的搭建(最全)

    万次阅读 2019-04-25 20:34:31
    1.安装docker(docker的版本与kubernetes 的版本兼容性需要注意) # 配置docker仓库 wget -P /etc/yum.repos.d/ https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo # 安装docker-ce-18.06.0.ce-3....
  • Kubernetes之服务发现Service

    千次阅读 2019-02-15 17:54:56
    原文:Kubernetes学习之路(十四)之服务发现Service 作者系列文章:https://www.cnblogs.com/linuxk/category/1248289.html 一、Service的概念  Kubernetes Pod 是有生命周期的,它们可以被创建,也可以被...
  • Kubernetes in Action中文版.pdf 下载

    千次阅读 2019-07-25 17:33:18
    https://download.csdn.net/download/a814902893/11431345
  • Kubernetes对Docker的版本支持列表

    万次阅读 2018-01-26 13:01:37
    Kubernetes 1.9 Kubernetes 1.8 Kubernetes 1.7 Kubernetes 1.6 Docker 1.10.3, 1.11.2, 1.12.6 Kubernetes 1.5 , 1.11.2, 1.12.3
  • k8s ingress 配置

    千次阅读 2018-06-06 11:48:09
    nginx.ingress.kubernetes.io/affinity 详见:点击打开链接Nametypenginx.ingress.kubernetes.io/add-base-url"true" or "false"nginx.ingress.kubernetes.io/app-rootstringnginx.ingress....
  • Kubernetes1.4正式发布

    千次阅读 2016-09-27 06:22:07
    昨天刚预测1.4即将正式发布,结果晚上12点,Kubernetes1.4就正式发布了。先看看Kubernetes发布历史: Kubernetes 1.0 - 2015年7月发布 Kubernetes 1.1 - 2015年11月发布 Kubernetes 1.2 - 2016年3月发布 ...
  • Kubernetes DNS Service技术研究

    万次阅读 2017-01-10 19:46:56
    本文主要是对kubernetes 1.2和1.3+的DNS Service的内部实现分别进行研究,得出其内部实现框架和交互逻辑,并对它们的实现进行了比较。
  • 期待下周Kubernetes1.6正式发布

    万次阅读 2017-03-15 10:35:24
    Kubernetes发布历史回顾  Kubernetes 1.0 - 2015年7月发布  Kubernetes 1.1 - 2015年11月发布  Kubernetes 1.2 - 2016年3月发布  Kubernetes 1.3 - 2016年7月发布  Kubernetes 1.4 - 2016年9...
  • Kubernetes1.6发布跟踪

    千次阅读 2017-01-13 10:23:32
    Kubernetes发布历史回顾  Kubernetes 1.0 - 2015年7月发布  Kubernetes 1.1 - 2015年11月发布  Kubernetes 1.2 - 2016年3月发布  Kubernetes 1.3 - 2016年7月发布  Kubernetes 1.4 - 2016年9月发布  ...
1 2 3 4 5 ... 20
收藏数 87,286
精华内容 34,914
关键字:

kubernetes