Kubernetes(K8s)入门指南

Kubernetes(K8s)入门指南

Kubernetes(K8s)是现代容器化应用管理的核心技术,广泛应用于自动化部署、扩展和管理容器化应用程序。无论你是初学者还是有经验的开发者,本指南将带你深入了解 Kubernetes 的基本操作、架构设计以及如何在 Kubernetes 上部署各种常见的应用和服务。通过本文,你将掌握 Kubernetes 的核心概念和实用技巧,轻松应对复杂的容器编排任务。准备好开始你的 Kubernetes 之旅了吗?让我们一同探索这个强大的开源平台吧!

一、Kubernetes使用简介

Kubernetes(K8s)是一个开源的容器编排平台,用于自动化容器化应用的部署、扩展和管理。以下是 Kubernetes 常用命令和操作的简要介绍(tldr):

1. 安装和配置

安装 kubectl(Kubernetes 命令行工具):

  • Linux

      curl -LO "https://dl.k8s.io/release/$(curl -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
      sudo chmod +x ./kubectl
      sudo mv ./kubectl /usr/local/bin/kubectl
    
  • macOS

      brew install kubectl
    
  • Windows

    下载 kubectl.exe 并添加到系统 PATH。

配置 kubectl 访问 Kubernetes 集群

kubectl config use-context <context-name>

2. 集群状态

查看集群信息

kubectl cluster-info

查看节点

kubectl get nodes

查看节点详细信息

kubectl describe node <node-name>

3. 命名空间

列出所有命名空间

kubectl get namespaces

创建命名空间

kubectl create namespace <namespace-name>

删除命名空间

kubectl delete namespace <namespace-name>

4. Pod 管理

列出所有 Pods

kubectl get pods

查看 Pod 详细信息

kubectl describe pod <pod-name>

查看 Pod 日志

kubectl logs <pod-name>

删除 Pod

kubectl delete pod <pod-name>

创建 Pod(使用 YAML 文件):

kubectl apply -f <pod-definition-file>.yaml

5. 部署管理

列出所有 Deployments

kubectl get deployments

查看 Deployment 详细信息

kubectl describe deployment <deployment-name>

创建 Deployment(使用 YAML 文件):

kubectl apply -f <deployment-definition-file>.yaml

更新 Deployment(滚动更新):

kubectl set image deployment/<deployment-name> <container-name>=<image>:<tag>

删除 Deployment

kubectl delete deployment <deployment-name>

6. 服务管理

列出所有 Services

kubectl get services

查看 Service 详细信息

kubectl describe service <service-name>

创建 Service(使用 YAML 文件):

kubectl apply -f <service-definition-file>.yaml

删除 Service

kubectl delete service <service-name>

7. 配置和密钥管理

列出 ConfigMaps

kubectl get configmaps

查看 ConfigMap 详细信息

kubectl describe configmap <configmap-name>

创建 ConfigMap(使用 YAML 文件):

kubectl apply -f <configmap-definition-file>.yaml

删除 ConfigMap

kubectl delete configmap <configmap-name>

列出 Secrets

kubectl get secrets

查看 Secret 详细信息

kubectl describe secret <secret-name>

创建 Secret(使用 YAML 文件):

kubectl apply -f <secret-definition-file>.yaml

删除 Secret

kubectl delete secret <secret-name>

8. 卷管理

列出 Persistent Volumes (PV)

kubectl get pv

查看 PV 详细信息

kubectl describe pv <pv-name>

列出 Persistent Volume Claims (PVC)

kubectl get pvc

查看 PVC 详细信息

kubectl describe pvc <pvc-name>

创建 PV/PVC(使用 YAML 文件):

kubectl apply -f <pv-or-pvc-definition-file>.yaml

删除 PV/PVC

kubectl delete pv <pv-name>
kubectl delete pvc <pvc-name>

9. 诊断和故障排除

查看集群事件

kubectl get events

查看集群的 API 资源

kubectl api-resources

查看资源的详细描述

kubectl describe <resource-type> <resource-name>

调试 Pod(进入 Pod 中的容器):

kubectl exec -it <pod-name> -- /bin/bash

这些基本命令和操作可以帮助你管理 Kubernetes 集群、部署和维护应用程序。

二、Kubernetes架构设计

Kubernetes 的架构设计是一个复杂的系统,涉及多个组件和概念。以下是 Kubernetes 架构的简要介绍(tldr):

1. 核心组件

1.1 控制平面(Control Plane)

  • Kubernetes API Server:负责处理 API 请求并与集群的其他组件进行通信。它是集群的中心控制点。

      API Server -> etcd
    
  • etcd:一个分布式键值存储,用于保存集群的配置数据和状态信息。它是 Kubernetes 的主要存储系统。

      API Server -> etcd
    
  • Controller Manager:运行集群中的控制器(如副本控制器、部署控制器等),负责维持集群的期望状态。

      Controller Manager -> API Server
    
  • Scheduler:负责将 Pods 调度到集群中的节点上。它根据资源需求、策略和其他约束来决定将 Pod 放在哪个节点上。

      Scheduler -> API Server
    

1.2 节点(Node)

  • Kubelet:在每个节点上运行,负责管理和确保容器的运行状态,负责与 API Server 通信,并执行容器的生命周期管理。

      Kubelet -> API Server
    
  • Kube-Proxy:负责维护网络规则,以便服务能够访问 Pod,并处理服务发现和负载均衡。

      Kube-Proxy -> API Server
    
  • Container Runtime:负责实际的容器运行和管理(如 Docker、containerd、CRI-O)。

      Container Runtime -> Kubelet
    

2. 核心概念

2.1 Pods:Kubernetes 中最小的可调度单元,可以包含一个或多个容器,这些容器共享网络、存储和配置。

2.2 Deployments:定义和管理 Pods 的副本,确保 Pods 的数量和状态符合期望。

2.3 Services:定义一组 Pods 的访问策略,提供负载均衡和服务发现功能。

2.4 ConfigMaps 和 Secrets:分别用于管理配置数据和敏感数据。

2.5 Volumes:持久存储,支持数据在 Pod 之间的共享和持久化。

2.6 Namespaces:用于在同一集群中划分逻辑隔离的空间,支持资源的组织和管理。

3. 数据流和操作

  • API 请求:用户通过 kubectl 或其他工具发起请求,API Server 处理这些请求并更新 etcd 中的状态信息。

  • 控制循环:控制器和调度器持续监控 API Server 中的状态,与期望状态进行对比,进行调整和更新。

  • 容器调度:Scheduler 根据集群状态和资源需求,将 Pods 调度到合适的节点上。

  • 容器管理:Kubelet 在节点上执行容器运行和管理任务,保持 Pod 的期望状态。

4. 高可用和扩展性

  • 高可用控制平面:可以通过运行多个 API Server、Controller Manager 和 Scheduler 实例来实现。

  • 节点扩展:可以动态添加和删除节点来扩展或缩减集群容量。

  • 分布式存储:etcd 和其他组件支持分布式部署以保证数据的持久性和高可用性。

通过这些组件和概念,Kubernetes 实现了容器化应用的自动化部署、扩展和管理。

三、部署ELK

在 Kubernetes 上部署 ELK(Elasticsearch, Logstash, Kibana)堆栈涉及多个步骤。ELK 堆栈是一个强大的日志处理和分析工具,广泛用于日志聚合和数据可视化。以下是简要的部署步骤(tldr):

1. 准备工作

确保你的 Kubernetes 集群已准备好,并且 kubectl 已配置为与集群通信。

2. 部署 Elasticsearch

Elasticsearch 是一个分布式搜索和分析引擎。你可以使用 Helm charts 或 YAML 配置文件来部署 Elasticsearch。

使用 Helm 部署

  1. 添加 Elastic Helm 仓库

     helm repo add elastic https://helm.elastic.co
     helm repo update
    
  2. 安装 Elasticsearch

     helm install elasticsearch elastic/elasticsearch
    

使用 YAML 文件部署

  1. 创建 Elasticsearch 部署 YAML 文件

    elasticsearch-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: elasticsearch
       labels:
         app: elasticsearch
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: elasticsearch
       template:
         metadata:
           labels:
             app: elasticsearch
         spec:
           containers:
           - name: elasticsearch
             image: docker.elastic.co/elasticsearch/elasticsearch:7.9.3
             env:
             - name: discovery.type
               value: single-node
             ports:
             - containerPort: 9200
             volumeMounts:
             - name: es-data
               mountPath: /usr/share/elasticsearch/data
           volumes:
           - name: es-data
             emptyDir: {}
    
  2. 应用 YAML 文件

     kubectl apply -f elasticsearch-deployment.yaml
    

3. 部署 Logstash

Logstash 是用于处理和转发日志数据的工具。与 Elasticsearch 类似,你可以使用 Helm 或 YAML 配置文件部署 Logstash。

使用 Helm 部署

  1. 安装 Logstash

     helm install logstash elastic/logstash
    

使用 YAML 文件部署

  1. 创建 Logstash 部署 YAML 文件

    logstash-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: logstash
       labels:
         app: logstash
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: logstash
       template:
         metadata:
           labels:
             app: logstash
         spec:
           containers:
           - name: logstash
             image: docker.elastic.co/logstash/logstash:7.9.3
             ports:
             - containerPort: 5044
             volumeMounts:
             - name: logstash-config
               mountPath: /usr/share/logstash/config
           volumes:
           - name: logstash-config
             configMap:
               name: logstash-config
    
  2. 创建 Logstash 配置 ConfigMap

    logstash-configmap.yaml

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: logstash-config
     data:
       logstash.conf: |
         input {
           beats {
             port => 5044
           }
         }
         output {
           elasticsearch {
             hosts => ["http://elasticsearch:9200"]
           }
         }
    
  3. 应用 YAML 文件

     kubectl apply -f logstash-configmap.yaml
     kubectl apply -f logstash-deployment.yaml
    

4. 部署 Kibana

Kibana 是用于可视化 Elasticsearch 数据的工具。

使用 Helm 部署

  1. 安装 Kibana

     helm install kibana elastic/kibana
    

使用 YAML 文件部署

  1. 创建 Kibana 部署 YAML 文件

    kibana-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: kibana
       labels:
         app: kibana
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: kibana
       template:
         metadata:
           labels:
             app: kibana
         spec:
           containers:
           - name: kibana
             image: docker.elastic.co/kibana/kibana:7.9.3
             ports:
             - containerPort: 5601
             env:
             - name: ELASTICSEARCH_HOSTS
               value: "http://elasticsearch:9200"
    
  2. 应用 YAML 文件

     kubectl apply -f kibana-deployment.yaml
    

5. 创建服务

创建服务暴露 Elasticsearch、Logstash 和 Kibana

  1. Elasticsearch 服务

    elasticsearch-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: elasticsearch
     spec:
       ports:
       - port: 9200
       selector:
         app: elasticsearch
    
  2. Logstash 服务

    logstash-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: logstash
     spec:
       ports:
       - port: 5044
       selector:
         app: logstash
    
  3. Kibana 服务

    kibana-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: kibana
     spec:
       ports:
       - port: 5601
       selector:
         app: kibana
    
  4. 应用服务 YAML 文件

     kubectl apply -f elasticsearch-service.yaml
     kubectl apply -f logstash-service.yaml
     kubectl apply -f kibana-service.yaml
    

6. 访问 Kibana

获取 Kibana 服务的外部 IP 地址

kubectl get services

使用浏览器访问 Kibana 的外部 IP 地址(通常是端口 5601)。

通过这些步骤,你可以在 Kubernetes 集群中部署和运行 ELK 堆栈,实现日志数据的收集、处理和可视化。

四、部署 Prometheus 和 Grafana

在 Kubernetes 集群中部署 Prometheus 和 Grafana 进行监控是一个常见的做法。Prometheus 是一个开源监控和警报系统,Grafana 是一个开源的数据可视化平台。以下是如何在 Kubernetes 上部署 Prometheus 和 Grafana 的步骤。

1. 部署 Prometheus

Prometheus 是一个用于收集和存储指标数据的系统。可以使用 Helm 或直接使用 YAML 文件来部署 Prometheus。

使用 Helm 部署 Prometheus

  1. 添加 Prometheus Helm 仓库

     helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
     helm repo update
    
  2. 安装 Prometheus

     helm install prometheus prometheus-community/prometheus
    

    这将自动创建 Prometheus 的部署、服务以及其他必要资源。

使用 YAML 文件部署 Prometheus

  1. 创建 Prometheus 配置 ConfigMap

    prometheus-configmap.yaml

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: prometheus-config
     data:
       prometheus.yml: |
         global:
           scrape_interval: 15s
         scrape_configs:
           - job_name: 'kubernetes-apiservers'
             kubernetes_sd_configs:
               - role: endpoints
             relabel_configs:
               - source_labels: [__meta_kubernetes_service_name]
                 action: keep
                 regex: kubernetes
    
  2. 创建 Prometheus 部署 YAML 文件

    prometheus-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: prometheus
       labels:
         app: prometheus
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: prometheus
       template:
         metadata:
           labels:
             app: prometheus
         spec:
           containers:
           - name: prometheus
             image: prom/prometheus:latest
             ports:
             - containerPort: 9090
             volumeMounts:
             - name: prometheus-config
               mountPath: /etc/prometheus
               subPath: prometheus.yml
           volumes:
           - name: prometheus-config
             configMap:
               name: prometheus-config
    
  3. 创建 Prometheus 服务 YAML 文件

    prometheus-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: prometheus
     spec:
       ports:
       - port: 9090
       selector:
         app: prometheus
    
  4. 应用 YAML 文件

     kubectl apply -f prometheus-configmap.yaml
     kubectl apply -f prometheus-deployment.yaml
     kubectl apply -f prometheus-service.yaml
    

2. 部署 Grafana

Grafana 用于将 Prometheus 收集的指标数据可视化。

使用 Helm 部署 Grafana

  1. 安装 Grafana

     helm install grafana grafana/grafana
    

    这将创建 Grafana 的部署、服务和相关资源。

使用 YAML 文件部署 Grafana

  1. 创建 Grafana 部署 YAML 文件

    grafana-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: grafana
       labels:
         app: grafana
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: grafana
       template:
         metadata:
           labels:
             app: grafana
         spec:
           containers:
           - name: grafana
             image: grafana/grafana:latest
             ports:
             - containerPort: 3000
    
  2. 创建 Grafana 服务 YAML 文件

    grafana-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: grafana
     spec:
       ports:
       - port: 3000
       selector:
         app: grafana
    
  3. 应用 YAML 文件

     kubectl apply -f grafana-deployment.yaml
     kubectl apply -f grafana-service.yaml
    

3. 配置 Prometheus 数据源

  1. 获取 Grafana 服务的外部 IP 地址

     kubectl get services
    
  2. 访问 Grafana:通过浏览器访问 Grafana 的外部 IP 地址(通常是端口 3000)。

  3. 登录 Grafana:默认用户名和密码通常是 admin / admin。你可以在 Grafana 的设置中更改密码。

  4. 添加 Prometheus 数据源

    • 登录到 Grafana。

    • 进入 Configuration > Data Sources

    • 点击 Add data source

    • 选择 Prometheus

    • 配置 Prometheus 的 URL(例如 http://prometheus:9090)。

    • 点击 Save & Test 确认连接成功。

4. 创建仪表板和可视化

  1. 创建 Grafana 仪表板

    • 进入 Create > Dashboard

    • 添加新的 Panel

    • 配置查询、图表和可视化选项。

    • 保存仪表板。

5. 监控和维护

  • 验证数据:确保 Grafana 能够从 Prometheus 获取数据,并且可视化显示正常。

  • 调整配置:根据需求调整 Prometheus 和 Grafana 的配置。

  • 定期检查:监控系统的运行状态和性能,定期检查日志和警报。

通过这些步骤,你可以在 Kubernetes 集群中部署 Prometheus 和 Grafana,构建一个强大的监控和可视化系统。

五、部署MySQL集群

在 Kubernetes 上部署 MySQL 集群,并配置主从复制(支持一主多从),涉及到多个步骤。你需要配置主数据库、从数据库以及它们之间的复制关系。以下是一个简要的指南,帮助你完成这一部署:

1. 准备工作

确保 Kubernetes 集群正常运行,并且 kubectl 已配置为与集群通信。

2. 部署 MySQL 主节点

使用 Helm 部署 MySQL

  1. 添加 Bitnami Helm 仓库(提供 MySQL chart):

     helm repo add bitnami https://charts.bitnami.com/bitnami
     helm repo update
    
  2. 安装 MySQL 主节点

     helm install mysql-master bitnami/mysql \
       --set replication.enabled=false \
       --set mysqlRootPassword=your_root_password \
       --set mysqlUser=your_user \
       --set mysqlPassword=your_password \
       --set mysqlDatabase=your_database
    

    这里 replication.enabled=false 表示这是主节点,主节点不需要复制功能。

3. 部署 MySQL 从节点

  1. 创建 MySQL 从节点的自定义值文件values-replica.yaml):

     replica:
       enabled: true
       replicas: 3
       configuration: |
         [mysqld]
         server-id=2
         log-bin=mysql-bin
         relay-log=mysqld-relay-bin
         binlog-do-db=your_database
     primary:
       service:
         name: mysql-master
       replication:
         enabled: true
         user: your_replication_user
         password: your_replication_password
         database: your_database
    

    这里 server-id=2 用于区分从节点。primary.service.name 应该与主节点服务名称匹配。

  2. 安装 MySQL 从节点

     helm install mysql-replicas bitnami/mysql \
       -f values-replica.yaml
    

4. 配置 MySQL 主从复制

  1. 获取主节点的连接信息

     kubectl get svc mysql-master
    

    记录下主节点的服务名称和端口。

  2. 在主节点上配置复制用户

    进入 MySQL 主节点的 Pod:

     kubectl exec -it <mysql-master-pod> -- mysql -uroot -p
    

    创建一个用于复制的用户:

     CREATE USER 'replication_user'@'%' IDENTIFIED BY 'replication_password';
     GRANT REPLICATION SLAVE ON *.* TO 'replication_user'@'%';
     FLUSH PRIVILEGES;
    

    获取主节点的二进制日志文件名和位置:

     SHOW MASTER STATUS;
    

    记录下 FilePosition 的值。

  3. 在从节点上配置复制

    进入 MySQL 从节点的 Pod:

     kubectl exec -it <mysql-replica-pod> -- mysql -uroot -p
    

    配置从节点连接到主节点:

     CHANGE MASTER TO
       MASTER_HOST='mysql-master',
       MASTER_USER='replication_user',
       MASTER_PASSWORD='replication_password',
       MASTER_LOG_FILE='mysql-bin.000001',  -- Replace with File from SHOW MASTER STATUS
       MASTER_LOG_POS= 4;  -- Replace with Position from SHOW MASTER STATUS
     START SLAVE;
    
  4. 验证复制状态

     SHOW SLAVE STATUS\G;
    

    确保 Slave_IO_RunningSlave_SQL_Running 都显示为 Yes

5. 维护和监控

  • 监控 MySQL 实例:使用 Prometheus + Grafana 或其他监控工具来监控 MySQL 的健康状态和性能。

  • 备份数据:配置备份和恢复策略以确保数据安全。

  • 故障排除:定期检查日志文件,确保复制正常进行。

通过这些步骤,你可以在 Kubernetes 上部署一个支持主从复制的 MySQL 集群,其中一个主节点和多个从节点。

六、部署MQ集群

在 Kubernetes 上部署一个消息队列(MQ)集群可以选择多种流行的消息队列系统,如 RabbitMQ、Apache Kafka 和 NATS 等。以下是如何在 Kubernetes 上部署 RabbitMQ 和 Apache Kafka 的步骤,因为这两个系统在生产环境中都非常流行,并且支持高可用性和分布式部署。

部署 RabbitMQ 集群

RabbitMQ 是一个流行的开源消息代理,支持 AMQP 协议,并且可以配置成集群模式以实现高可用性。

使用 Helm 部署 RabbitMQ

  1. 添加 Bitnami Helm 仓库

     helm repo add bitnami https://charts.bitnami.com/bitnami
     helm repo update
    
  2. 安装 RabbitMQ 集群

     helm install rabbitmq bitnami/rabbitmq \
       --set replicaCount=3 \
       --set auth.username=your_user \
       --set auth.password=your_password \
       --set auth.erlangCookie=your_erlang_cookie
    
    • replicaCount=3 表示部署一个包含 3 个 RabbitMQ 节点的集群。

    • auth.usernameauth.password 是 RabbitMQ 的管理用户名和密码。

    • auth.erlangCookie 是 RabbitMQ 节点之间通信的 Erlang Cookie,必须相同。

使用 YAML 文件部署 RabbitMQ

  1. 创建 RabbitMQ 配置文件

    rabbitmq-configmap.yaml

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: rabbitmq-config
     data:
       rabbitmq.conf: |
         loopback_users.guest = false
    
  2. 创建 RabbitMQ 部署 YAML 文件

    rabbitmq-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: rabbitmq
       labels:
         app: rabbitmq
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: rabbitmq
       template:
         metadata:
           labels:
             app: rabbitmq
         spec:
           containers:
           - name: rabbitmq
             image: bitnami/rabbitmq:latest
             ports:
             - containerPort: 5672
             - containerPort: 15672
             env:
             - name: RABBITMQ_ERLANG_COOKIE
               value: "your_erlang_cookie"
             - name: RABBITMQ_DEFAULT_USER
               value: "your_user"
             - name: RABBITMQ_DEFAULT_PASS
               value: "your_password"
             volumeMounts:
             - name: config-volume
               mountPath: /opt/bitnami/rabbitmq/conf
               subPath: rabbitmq.conf
           volumes:
           - name: config-volume
             configMap:
               name: rabbitmq-config
    
  3. 创建 RabbitMQ 服务 YAML 文件

    rabbitmq-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: rabbitmq
     spec:
       ports:
       - port: 5672
         name: amqp
       - port: 15672
         name: management
       selector:
         app: rabbitmq
    
  4. 应用 YAML 文件

     kubectl apply -f rabbitmq-configmap.yaml
     kubectl apply -f rabbitmq-deployment.yaml
     kubectl apply -f rabbitmq-service.yaml
    

部署 Apache Kafka 集群

Apache Kafka 是一个分布式流平台,适用于大规模消息传递和流数据处理。

使用 Helm 部署 Apache Kafka

  1. 添加 Bitnami Helm 仓库

     helm repo add bitnami https://charts.bitnami.com/bitnami
     helm repo update
    
  2. 安装 Apache Kafka 集群

     helm install kafka bitnami/kafka \
       --set replicaCount=3 \
       --set zookeeper.enabled=true \
       --set zookeeper.replicaCount=3
    
    • replicaCount=3 表示部署一个包含 3 个 Kafka 节点的集群。

    • zookeeper.replicaCount=3 表示部署一个包含 3 个 Zookeeper 节点的集群。

使用 YAML 文件部署 Apache Kafka

  1. 创建 Zookeeper 部署 YAML 文件

    zookeeper-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: zookeeper
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: zookeeper
       template:
         metadata:
           labels:
             app: zookeeper
         spec:
           containers:
           - name: zookeeper
             image: bitnami/zookeeper:latest
             ports:
             - containerPort: 2181
    
  2. 创建 Kafka 部署 YAML 文件

    kafka-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: kafka
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: kafka
       template:
         metadata:
           labels:
             app: kafka
         spec:
           containers:
           - name: kafka
             image: bitnami/kafka:latest
             ports:
             - containerPort: 9092
             env:
             - name: KAFKA_ZOOKEEPER_CONNECT
               value: "zookeeper:2181"
    
  3. 创建 Kafka 服务 YAML 文件

    kafka-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: kafka
     spec:
       ports:
       - port: 9092
         name: kafka
       selector:
         app: kafka
    
  4. 应用 YAML 文件

     kubectl apply -f zookeeper-deployment.yaml
     kubectl apply -f kafka-deployment.yaml
     kubectl apply -f kafka-service.yaml
    

维护和监控

  • 监控 MQ 实例:使用监控工具(如 Prometheus + Grafana)来监控消息队列的健康状态和性能。

  • 备份数据:配置数据备份和恢复策略,确保数据安全。

  • 故障排除:检查日志文件,确保消息队列正常运行并解决任何问题。

通过这些步骤,你可以在 Kubernetes 集群中部署一个支持高可用性的 RabbitMQ 或 Apache Kafka 集群。根据需要选择适合你的消息队列系统。

七、部署codis集群

Codis 是一个高可用的 Redis 集群解决方案,支持分片和高可用性。如果你想在 Kubernetes 集群上部署 Codis,以下是一个基本的指南。这个指南涵盖了 Codis 的主要组件,包括 Codis Proxy、Codis Dashboard 和 Codis Server。

1. 准备工作

确保 Kubernetes 集群已经正常运行,并且 kubectl 已配置为与集群通信。

2. 部署 Codis Server(Redis 实例)

Codis Server 是实际的数据存储部分,通常运行多个 Redis 实例来实现分片。

  1. 创建 Codis Server 部署 YAML 文件

    codis-server-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: codis-server
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: codis-server
       template:
         metadata:
           labels:
             app: codis-server
         spec:
           containers:
           - name: redis
             image: redis:latest
             ports:
             - containerPort: 6379
    
  2. 创建 Codis Server 服务 YAML 文件

    codis-server-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: codis-server
     spec:
       ports:
       - port: 6379
         targetPort: 6379
       selector:
         app: codis-server
    
  3. 应用 YAML 文件

     kubectl apply -f codis-server-deployment.yaml
     kubectl apply -f codis-server-service.yaml
    

3. 部署 Codis Proxy

Codis Proxy 充当客户端与 Codis Server 之间的中间层,实现负载均衡和请求路由。

  1. 创建 Codis Proxy 部署 YAML 文件

    codis-proxy-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: codis-proxy
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: codis-proxy
       template:
         metadata:
           labels:
             app: codis-proxy
         spec:
           containers:
           - name: codis-proxy
             image: codis/codis-proxy:latest
             ports:
             - containerPort: 19000
    
  2. 创建 Codis Proxy 服务 YAML 文件

    codis-proxy-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: codis-proxy
     spec:
       ports:
       - port: 19000
         targetPort: 19000
       selector:
         app: codis-proxy
    
  3. 应用 YAML 文件

     kubectl apply -f codis-proxy-deployment.yaml
     kubectl apply -f codis-proxy-service.yaml
    

4. 部署 Codis Dashboard

Codis Dashboard 是 Codis 集群的管理界面,用于监控和管理 Codis 集群。

  1. 创建 Codis Dashboard 部署 YAML 文件

    codis-dashboard-deployment.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: codis-dashboard
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: codis-dashboard
       template:
         metadata:
           labels:
             app: codis-dashboard
         spec:
           containers:
           - name: codis-dashboard
             image: codis/codis-dashboard:latest
             ports:
             - containerPort: 18080
    
  2. 创建 Codis Dashboard 服务 YAML 文件

    codis-dashboard-service.yaml

     apiVersion: v1
     kind: Service
     metadata:
       name: codis-dashboard
     spec:
       ports:
       - port: 18080
         targetPort: 18080
       selector:
         app: codis-dashboard
    
  3. 应用 YAML 文件

     kubectl apply -f codis-dashboard-deployment.yaml
     kubectl apply -f codis-dashboard-service.yaml
    

5. 配置和初始化 Codis

  1. 访问 Codis Dashboard:通过浏览器访问 Codis Dashboard 的外部 IP 地址(通常是端口 18080)。

  2. 配置 Codis 集群

    • 在 Codis Dashboard 中,配置 Redis 实例和 Codis Proxy 的连接。

    • 配置分片和负载均衡策略。

  3. 监控和管理

    • 使用 Codis Dashboard 监控 Redis 实例的健康状态。

    • 配置报警和性能监控。

6. 维护和监控

  • 监控 Codis 集群:使用监控工具(如 Prometheus + Grafana)来监控 Codis 的健康状态和性能。

  • 备份数据:配置备份和恢复策略,确保数据安全。

  • 故障排除:检查日志文件,确保 Codis 集群正常运行并解决任何问题。

通过这些步骤,你可以在 Kubernetes 集群中部署 Codis 集群,实现高可用的 Redis 服务。

八、部署CI/CD系统

在 Kubernetes 上部署 CI/CD 系统可以帮助自动化构建、测试和部署流程。以下是常见的 CI/CD 系统的部署步骤示例,包括 Jenkins XArgo CD,两个流行的 Kubernetes 原生 CI/CD 工具。

1. Jenkins X

Jenkins X 是一个基于 Kubernetes 的 CI/CD 系统,提供 GitOps 工作流和自动化功能。

部署 Jenkins X

  1. 安装 Jenkins X CLI

     curl -L https://github.com/jenkins-x/jx/releases/download/v3.2.279/jx-linux-amd64.tar.gz | tar xzv
     sudo mv jx /usr/local/bin
    
  2. 创建 Kubernetes 集群(如果尚未创建):

    你可以使用任何云提供商或本地工具创建 Kubernetes 集群。

  3. 初始化 Jenkins X

     jx create cluster <provider>  # 例如: jx create cluster gke
    
  4. 安装 Jenkins X

     jx install
    
  5. 配置 Jenkins X

    • 选择要使用的 Git 服务(如 GitHub、GitLab)。

    • 配置用于构建和部署的环境。

  6. 访问 Jenkins X

    Jenkins X 会自动设置好服务,通常可以通过集群的外部 IP 或端口访问。

2. Argo CD

Argo CD 是一个 Kubernetes 原生的持续交付工具,支持 GitOps 模式。

部署 Argo CD

  1. 创建 Kubernetes 集群(如果尚未创建)。

  2. 安装 Argo CD

     kubectl create namespace argocd
     kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    
  3. 访问 Argo CD

    通过 kubectl port-forward 将 Argo CD 的 API 服务器暴露到本地:

     kubectl port-forward svc/argocd-server -n argocd 8080:443
    

    然后在浏览器中访问 http://localhost:8080

  4. 登录 Argo CD

    获取初始管理员密码:

     kubectl get secret argocd-initial-admin-secret -n argocd -o yaml
    

    登录到 Argo CD Web 界面,使用用户名 admin 和获取的密码。

  5. 配置 GitOps

    • 在 Argo CD 中创建应用,指定 Git 仓库和部署路径。

    • Argo CD 将自动同步应用的状态与 Git 仓库中的配置。

3. 其他 CI/CD 工具

如果你需要其他 CI/CD 工具,以下是一些常见的选择:

  • GitLab CI/CD

    • GitLab 提供内置的 CI/CD 功能,支持 Kubernetes 集群部署。

    • 官方文档

  • Tekton

    • 一个 Kubernetes 原生的 CI/CD 系统,支持管道和任务。

    • 官方文档

  • Jenkins

    • 传统的 CI/CD 工具,可通过 Kubernetes 部署 Jenkins Master 和 Agent。

    • 官方文档

这些 CI/CD 工具可以帮助你在 Kubernetes 集群上实现自动化构建、测试和部署,选择适合你需求的工具来提升开发和运维效率。

附录

k8s前端界面使用指南

在 Kubernetes 中,前端界面通常指的是可视化工具和管理控制台,它们用于简化集群的管理和监控。以下是常见的 Kubernetes 前端界面的简要概述:

1. Kubernetes Dashboard

  • 功能:Kubernetes 官方提供的图形用户界面,用于监控和管理集群资源。

  • 特点

    • 查看集群状态、Pod、服务、部署等。

    • 提供集群资源的详细信息和管理功能。

  • 安装

      kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.5.0/aio/deploy/recommended.yaml
    
  • 访问

      kubectl proxy
      # 通过浏览器访问
      http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/
    

2. Lens

  • 功能:开源的 Kubernetes IDE,提供集群管理和监控功能。

  • 特点

    • 支持多集群管理。

    • 可视化的资源浏览器和日志查看。

    • 插件支持扩展功能。

  • 安装:从 Lens 官网 下载并安装客户端应用。

3. Octant

  • 功能:开源的 Kubernetes 管理界面,由 VMware 开发。

  • 特点

    • 实时监控 Kubernetes 集群状态。

    • 提供丰富的资源视图和交互功能。

  • 安装

      brew install octant
    
  • 启动

      octant
      # 通过浏览器访问 http://localhost:7777
    

4. Rancher

  • 功能:全面的 Kubernetes 管理平台,适用于多集群管理。

  • 特点

    • 支持集群的创建和管理。

    • 提供强大的用户权限管理和多集群操作功能。

  • 安装

      docker run -d --restart=unless-stopped -p 80:80 -p 443:443 rancher/rancher:latest
    
  • 访问:通过浏览器访问 https://<your-rancher-ip>

5. Portainer

  • 功能:用户友好的容器管理工具,也支持 Kubernetes。

  • 特点

    • 提供简洁的用户界面来管理 Kubernetes 集群。

    • 支持容器和镜像的可视化管理。

  • 安装

      docker run -d -p 9000:9000 --name portainer --restart=always portainer/portainer-ce
    
  • 访问:通过浏览器访问 http://localhost:9000

这些前端界面可以帮助你更高效地管理和监控 Kubernetes 集群,选择合适的工具取决于你的需求和使用场景。

可视化和管理服务依赖关系

在 Kubernetes 上搭建一个开源服务树管理应用通常涉及使用合适的开源工具来可视化和管理服务依赖关系。以下是一个示例,展示如何使用 Kiali 作为开源服务树管理应用来实现这一目标。Kiali 是一个用于可视化和管理服务网格的工具,特别适用于 Istio 服务网格。

1. 准备工作

确保你有一个运行中的 Kubernetes 集群和已安装的 Istio 服务网格,因为 Kiali 通常与 Istio 配合使用。

2. 安装 Istio

  1. 下载 Istio 安装程序

     curl -L https://istio.io/downloadIstio | sh -
    
  2. 安装 Istio CLI

     export PATH=$PATH:`pwd`/istio-<version>/bin
    
  3. 安装 Istio 默认配置

     istioctl install --set profile=demo
    
  4. 启用自动注入 sidecar

     kubectl label namespace default istio-injection=enabled
    
  5. 部署示例应用(可选,但推荐用于测试):

     kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.14/samples/bookinfo/platform/kube/bookinfo.yaml
    

3. 安装 Kiali

  1. 安装 Kiali

    如果你使用的是 Istio 的 Helm Chart,你可以通过以下命令安装 Kiali:

     helm install kiali-server kiali/kiali-server --namespace istio-system
    

    或者通过 Istio 的 istioctl 工具:

     istioctl manifest apply --set values.kiali.enabled=true
    
  2. 验证 Kiali 部署

     kubectl get pods -n istio-system
    

    确保 kiali Pod 正在运行。

  3. 获取 Kiali 的访问地址

     kubectl get svc -n istio-system
    

    记录下 kiali 服务的 EXTERNAL-IP 或使用 kubectl port-forward 来访问:

     kubectl port-forward svc/kiali -n istio-system 20001:20001
    
  4. 访问 Kiali

    通过浏览器访问 http://localhost:20001,你将看到 Kiali 的用户界面。

4. 配置和使用 Kiali

  1. 配置服务树视图

    • 在 Kiali 的用户界面中,你可以查看到服务网格的拓扑图。

    • Kiali 会自动从 Istio 收集服务的流量数据并绘制服务依赖图(服务树)。

  2. 监控和分析

    • 使用 Kiali 的功能来监控流量、查看服务间的调用关系、分析请求的延迟和错误等。
  3. 安全和访问控制

    • 配置用户权限和访问控制,以保护你的 Kiali 界面。

5. 维护和监控

  • 更新:定期更新 Kiali 和 Istio 以获取新功能和安全修复。

  • 备份:根据需要配置备份策略,确保数据的持久性。

  • 故障排除:检查 Kiali 和 Istio 的日志,解决任何出现的问题。

通过这些步骤,你可以在 Kubernetes 上成功搭建一个开源服务树管理应用(如 Kiali),用于可视化和管理你的服务网格。

Kubernetes 生态系统

Kubernetes 生态系统包括多个组件和工具,协同工作以管理和优化容器化应用程序的部署、运行和维护。

  • 核心组件

    • Kubernetes API Server:集群的中心控制点,处理所有 API 请求。

    • Scheduler:分配 Pod 到合适的节点。

    • Controller Manager:管理集群的状态,确保实际状态符合期望状态。

    • Kubelet:在每个节点上运行,管理 Pod 的生命周期。

    • Kube Proxy:提供网络代理服务,处理服务的负载均衡。

    • etcd:分布式键值存储,用于存储集群的配置和状态数据。

  • 常用工具

    • kubectl:命令行工具,用于与 Kubernetes 集群交互。

    • Helm:包管理工具,用于简化应用程序的部署和管理。

    • kubeadm:用于集群的初始化和管理。

  • 监控和日志

    • Prometheus:开源监控系统,集成 Grafana 进行可视化。

    • ELK Stack(Elasticsearch, Logstash, Kibana):用于日志收集、分析和可视化。

  • 服务网格

    • Istio:服务网格平台,提供流量管理、服务治理和安全功能。

    • Linkerd:另一个流行的轻量级服务网格。

  • CI/CD

    • Argo CD:持续交付工具,支持 GitOps 模式。

    • Jenkins X:自动化 CI/CD 平台,集成 Kubernetes 和 GitOps。

  • 存储和网络

    • StorageClass:定义不同类型的存储,支持动态卷供应。

    • CalicoWeave:网络插件,提供网络策略和多租户支持。

  • 开发和调试

    • Kubernetes Dashboard:集群的图形用户界面,用于管理和监控集群资源。

    • Skaffold:开发工具,简化应用程序的构建、部署和迭代。

Kubernetes 生态系统提供了一整套工具和组件,帮助用户管理复杂的容器化应用程序和微服务架构。

Istio

Istio 是一个开源的服务网格平台,提供了流量管理、服务治理、安全和可观察性功能,帮助管理和保护微服务架构中的应用。

  • 主要功能

    • 流量管理:控制和分配服务间的流量,支持流量镜像、蓝绿部署等。

    • 安全:提供服务间的身份验证、授权和加密通信。

    • 可观察性:监控和跟踪服务的性能,包括日志、指标和分布式追踪。

    • 政策管理:实施访问控制、流量控制和速率限制等策略。

  • 组件

    • Envoy:轻量级代理,注入到服务的 sidecar 中,处理流量和策略。

    • Pilot:配置和管理 Envoy 代理。

    • Mixer:处理遥测数据和策略检查。

    • Citadel:提供服务间的身份验证和密钥管理。

    • Galley:配置验证和分发。

  • 安装

    • 可以通过 istioctl、Helm 或直接应用 Kubernetes YAML 文件来安装。
  • 访问

    • 提供多种控制面板和 CLI 工具来管理和监控服务网格。

Istio 是一个强大的服务网格解决方案,适用于需要精细流量控制和综合可观察性的现代应用架构。