Ubuntu22.04.2 k8s部署

k8s介绍

简单介绍

通俗易懂的解释：

Kubernetes（也被称为 K8s）就像是一个大管家，帮你管理你的云计算服务。想象一下，你有很多个小程序（我们称之为"容器"），每个都在做不同的事情，而 Kubernetes 就是帮你确保这些小程序都能按照你的要求运行，如果有哪个小程序出了问题，Kubernetes 会自动修复或者替换它，确保你的服务始终可用。

专业术语的解释：

Kubernetes 是一个开源的容器编排系统，用于自动化应用容器的部署、扩展和管理。它提供了平台即服务（PaaS）的简易性以及基础设施即服务（IaaS）的灵活性，并支持跨主机集群的服务发现和负载均衡。Kubernetes 提供了一种环境，使得你可以在分布式系统中运行弹性工作负载，同时还能够管理和扩展这些工作负载以满足你的特定需求。

k8s学习路线

一些资料

Sealos 私有化部署完全指南 - 米开朗基杨 - 博客园

Python实战：Kubernetes集群中部署Python应用_python kubernetes-CSDN博客

kubernetes（K8s）-sealos私有化部署完整指南-CSDN博客

一些可学习的视频

【完整版Kubernetes（K8S）全套入门+微服务实战项目，带你一站式深入掌握K8S核心能力】完整版Kubernetes（K8S）全套入门+微服务实战项目，带你一站式深入掌握K8S核心能力_哔哩哔哩_bilibili

【【2024版】最新最全最详细的kubernetes（k8s 1.27）入门教程，Java程序员转行k8s架构师必看（k8s教程/k8s安装）】【2024版】最新最全最详细的kubernetes（k8s 1.27）入门教程，Java程序员转行k8s架构师必看（k8s教程/k8s安装）_哔哩哔哩_bilibili 课件链接：无废话纯享版 k8s 1.27.x 枫叶云笔记

【【整整300集】字节跳动196小时讲完的kubernetes（k8s）教程，让你自学k8s少走99%的弯路！（k8s教程/k8s部署/k8s安装/k8s实战）】【整整300集】字节跳动196小时讲完的kubernetes（k8s）教程，让你自学k8s少走99%的弯路！（k8s教程/k8s部署/k8s安装/k8s实战）_哔哩哔哩_bilibili

【【Sealos】60分钟带你使用sealos私有化部署Kubernetes（k8s）集群！k8s安装/k8s部署/k8s实战】【Sealos】60分钟带你使用sealos私有化部署Kubernetes（k8s）集群！k8s安装/k8s部署/k8s实战_哔哩哔哩_bilibili

基础理论：

• 容器化应用的概念

• 分布式系统的设计原则

• Linux 操作系统和常用命令

安装 Kubernetes：

• 在本地机器上安装 Minikube 或使用云服务提供商（如 GKE，AKS，EKS）

核心概念：

• Pods

• Deployments

• Services

• Ingress

• Volumes

• ConfigMaps

• Secrets

进阶概念：

• StatefulSets

• DaemonSets

• Jobs

• CronJobs

• Namespaces

• RBAC

• Horizontal Pod Autoscaling (HPA)

• Cluster Autoscaling

网络和存储扩展：

• 网络策略（Network Policies）

• 持久化卷（Persistent Volumes）

集群管理和自动化：

• Helm - Kubernetes 的包管理工具

• CI/CD 流水线与 Jenkins, GitLab CI, GitHub Actions 集成

调试和监控：

• kubectl 命令行工具

• Kubernetes Dashboard

• Prometheus

• Grafana

高级特性：

• Service Mesh (Istio, Linkerd)

• Logging (ELK, Fluentd)

• Tracing (Jaeger, OpenTracing)

最佳实践：

• 设计模式（如12要素应用，微服务）

• 监控和报警

• 故障排查

• 安全最佳实践

实践操作：

• 部署应用

• 扩展应用

• 更新和回滚应用

• 管理配置和机密

• 监控和调试问题

Kubernetes 进阶：

• 自定义资源定义（CRDs）

• Operators 开发

• 使用 Go 或 Python 编写自定义控制器

管理 Kubernetes：

• 使用 kubeadm 或其他工具部署 Kubernetes 集群

• 维护和升级集群

• 维护多个集群

云原生架构和最佳实践：

• 微服务架构

• Declarative API (YAML 配置文件)

• 不可变基础设施

• 使用 GitOps 管理配置

这只是一个学习路线图的概要，实际学习过程中会涉及到更多的细节和实践操作。建议按照这个路线图逐步进行学习和实践。

k8s框架

图解

master节点与node节点

在Kubernetes中，Master节点负责管理和调度集群中的所有资源。它由多个核心组件组成，包括kube-apiserver、kube-controller-manager和kube-scheduler。这些组件通常需要部署在同一台机器上。

• kube-apiserver：提供了HTTP Rest接口的关键服务进程，是Kubernetes里所有资源的增、删、改、查等操作的唯一入口。

• kube-controller-manager：Kubernetes里所有资源对象的自动化控制中心。

• kube-scheduler：负责资源调度（Pod调度）的进程。

当你部署一个应用时，你实际上是在向Master节点的kube-apiserver提交一个请求。这个请求描述了你想要部署的应用的状态，包括应用的镜像、副本数、网络设置等。kube-apiserver接收到这个请求后，会将其保存在etcd中。

然后，kube-scheduler和kube-controller-manager会根据这个请求来调度和管理Pod。kube-scheduler负责决定将Pod部署在哪个Node节点上，而kube-controller-manager则负责监控Pod的状态，并在需要时进行自动扩缩容。

至于Node节点，它们主要负责运行Pod。每个Node节点上都运行着kubelet和kube-proxy两个进程。

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

• kube-proxy：实现Kubernetes Service的通信以及负载均衡。

Node节点可以在运行期间动态增加到Kubernetes集群中，前提是这个节点上已经正确安装、配置和启动了上述关键进程。一旦Node被纳入集群管理范围，kubelet进程就会定时向Master节点汇报自身的情报，例如操作系统、Docker版本、机器的CPU和内存情况，以及当前有哪些Pod在运行等。这样，Master可以获知每个Node的资源使用情况，并实现高效均衡等资源调度策略。

所以，从这个角度来看，部署应用的操作是由Master节点进行的，但实际运行应用的是Node节点。而Node节点并不只有查看权限，它们也有执行操作的权限，比如创建和管理Pod。

消耗资源是master的还是node的

在Kubernetes中，应用程序实际上是在Node节点上运行的，因此，应用程序会消耗Node节点的计算资源（如CPU和内存）和存储资源。Master节点主要负责管理和调度，而不直接运行应用程序。

当你部署一个应用程序时，你会向Master节点发送一个请求，描述你想要部署的应用程序的状态。然后，Master节点的调度器（Scheduler）会决定将应用程序的Pods部署在哪个Node节点上。一旦Pods被调度到一个Node节点上，它们就会开始在那里运行，并消耗那个节点的资源。

所以，当我们说"部署一个项目"，实际上是指在Master节点上创建和管理部署请求，而实际的资源消耗（如CPU、内存和存储）发生在运行应用程序的Node节点上。

k8s部署应用后和节点关联

在 Kubernetes（K8s）中，应用程序是通过部署（Deployment）在各个节点（Node）上运行的容器实例来实现的。这些容器实例被包含在一个叫做 Pod 的概念中，Pod 是 Kubernetes 中最小可管理的单元。

当你在 Kubernetes 中部署一个应用程序时，你实际上是创建了一个 Deployment。Deployment 会指示 Kubernetes 如何创建和更新应用程序的实例。这些实例（Pods）会被 Kubernetes 的调度器（Scheduler）分配到集群中的具体的节点（Node）上。

一旦 Pod 被调度到一个 Node 上，它就会在那个 Node 上运行，并消耗那个 Node 的计算资源（如 CPU 和内存）。如果运行 Pod 的 Node 发生故障或被删除，Kubernetes 的 Deployment Controller 会在集群中的另一个 Node 上重新创建一个新的 Pod。这提供了一种自我修复机制，可以处理机器故障或维护问题。

因此，部署应用程序后，应用程序与 Kubernetes 集群中的节点有紧密的关联。应用程序的运行、扩展和故障恢复都依赖于 Kubernetes 对节点的管理和调度。 ### k8s的用途和实际意义 Kubernetes（也被称为 K8s）是一个开源的容器编排平台，它在实际应用中有着广泛的用途和重要的意义： #### 自动化部署 **自动化部署**：Kubernetes可以自动化部署容器化的应用，无需运维人员进行复杂的手动配置和处理。 Kubernetes可以通过读取容器定义文件（既yaml文件）来创建和管理Pod。当Pod的状态发生变化时，Kubernetes会自动更新容器以反映这些变化。 #### 大规模可伸缩 **大规模可伸缩**：Kubernetes可以管理和扩展大规模的应用容器，以满足不断变化的业务需求。 Kubernetes提供了一种机制叫做KEDA，它可以根据Prometheus指标来动态缩放应用程序的规模 **KEDA (Kubernetes Event-Driven Autoscaling)** 是一个基于 Kubernetes 的事件驱动自动缩放 器。它的工作原理是从外部度量提供者系统（例如 Prometheus）监控度量，然后根据基于度量值 的伸缩规则进行伸缩。KEDA 并没有取代 Kubernetes 内置的水平 Pod 自动缩放器 (HPA)，它仍然 使用 HPA 来发挥它的魔力。 **Prometheus** 是一个开源的系统监控和警报工具。它将所有指标数据存储为时间序列，即指标信息与记录时间戳一起存储，还可以存储可选的键-值对标签与指标一起。Prometheus 的基本原理是通过 HTTP 协议周期性抓取被监控组件的状态，任意组件只要提供对应的 HTTP 接口就可以接入监控。 Prometheus 的指标（Metrics）是它收集的数据的核心，这些数据被存储为时间序列，即在不同 时间点的数据值。Prometheus 支持四种类型的指标： * **Counter**：一个只增不减的累计值，例如请求总数。 * **Gauge**：一个可以任意上下浮动的瞬时值，例如 CPU 利用率。 * **Histogram**：一种度量样本的指标，它也提供了所有值的总和和个数。例如，请求持续时间的直方图。 * **Summary**：类似于直方图，但是它可以在服务端计算出可靠的分位数。 希望这些信息能帮助你理解 KEDA 和 Prometheus 指标。 #### 负载均衡 Kubernetes内置的负载均衡策略可以实现对应用实例的管理、发现、访问。例如，集群外就可以使用Kubernetes任意一个节点的IP加上30000端口访问该服务了。 #### 资源优化 Kubernetes可以高效地利用内存、处理器等资源，节省开销。例如，可以通过监测集群资源使用率和调整节点资源配额来管理Kubernetes集群的配置。 #### **跨环境部署** 无论是物理服务器、虚拟机、公共云环境，还是私有云和混合云环境，Kubernetes都可以在其中运行。例如，我们可以将全部服务器建立一个集群，在集群中任意一个Master节点创建一个Service与多个容器Pod，每个容器Pod内运行一个应用实例，然后通过Kubernetes内置的负载均衡策略，实现对这一组应用实例的管理、发现、访问。 #### **持续集成/持续部署（CI/CD）** Kubernetes可以简化CI/CD流程，使得应用的更新和迭代更加高效。例如，可以与企业内部原有的持续构建集成，例如Jenkins，也可以在Kubernetes中部署一套新的持续构建与发布工具，例如Drone、ArgoCD、Tekton等。 #### **提高可靠性** Kubernetes能够确保应用一直顺利运行，即使出现故障，Kubernetes也会自动恢复，提供应用程序的不间断操作。例如，我们可以配置存活性检测（Liveness Probes），如果存活性检测没有通过，Kubernetes会自动来重启这个应用。对于状态2，我们可以配置可用性检测（Readiness Probes），这样在服务初始化完成前，通过Service不能访问到这个服务，避免造成意想不到的后果。 #### 微服务架构支持 Kubernetes非常适合部署和管理基于微服务架构的应用。例如，Kubernetes通过读取容器定义文件来创建和管理Pod。当Pod的状态发生变化时，Kubernetes会自动更新容器以反映这些变化。 总的来说，Kubernetes通过自动化的方式，使得应用的部署、管理和扩展变得更加简单和高效，大大提高了IT运维的效率和应用的可靠性。 ### k8s解决的问题 1. **服务部署和扩展**：Kubernetes可以自动部署、扩展和管理容器化的应用程序，使得服务部署和扩展变得更加简单和快速。 就像你有一个机器人厨师，你告诉他你需要多少个汉堡，他就会自动做出相应数量的汉堡。如果你需要更多的汉堡，他会自动做更多。 2. **服务发现和负载均衡**：Kubernetes可以自动发现和平衡负载，从而提高服务的可用性和稳定性。 如果你有很多机器人厨师，Kubernetes就像一个经理，它会确保每个厨师的工作量都差不多，没有人会被压垮。 3. **自动回滚和恢复**：Kubernetes可以在应用程序出现故障时自动回滚和恢复，从而提高服务的可靠性。 如果一个机器人厨师犯了错误（比如做出了一个不好吃的汉堡），Kubernetes会让他停下来，然后找另一个机器人厨师接替他的工作。 4. **密钥和配置管理**：Kubernetes可以管理和保护敏感数据，如密码、OAuth令牌和SSH密钥。 Kubernetes就像一个保险箱，它可以安全地存储和管理你的秘密配方和其他重要信息。 5. **存储编排**：Kubernetes允许你自动挂载你选择的存储系统，例如本地存储、公共云提供商等。 如果你的机器人厨师需要某种特殊的食材，Kubernetes会确保他们可以在需要的时候获取到。 6. **批处理和CI/CD**：Kubernetes可以管理批处理和CI/CD工作流，替代传统的主机依赖的工作流。 Kubernetes可以管理你的整个厨房工作流程，确保每个步骤都按照计划进行。 7. **资源优化**：Kubernetes可以根据资源需求和约束自动放置容器，从而提高资源利用率。 Kubernetes会确保每个机器人厨师都有足够的资源（比如时间和空间）来完成他们的工作，但又不会浪费任何资源。 8. **自我修复**：Kubernetes可以在容器失败时自动替换和重新调度容器，当节点死亡时，它可以替换和重新调度节点上的容器，当容器不通过你定义的健康检查时，它可以杀死它们，并且，当准备好服务时，它不会将其通告给客户端，直到它们准备好开始接受流量。 如果一个机器人厨师坏了，Kubernetes会自动找到问题并修复它，或者找到另一个机器人厨师来接替他的工作。 ### sealos和k8s的关系 **Sealos** 是一个基于Go语言开发的简单干净且Kubernetes集群部署工具。它可以帮助用户在生产环境中部署高可用的Kubernetes集群。Sealos提供的API与Kubernetes的CRD (Custom Resource Definitions，自定义资源定义)设计完全兼容。用户可以通过Sealos的API，以与操作Kubernetes环境相同的方式来管理和控制他们的云资源。 **Kubernetes**（简称K8s）是一个开源的容器编排系统，用于自动化部署、扩展和管理容器化应用程序。 因此，Sealos和Kubernetes的关系可以理解为：Sealos是一个工具，它使用Kubernetes作为内核，帮助用户更方便地部署和管理Kubernetes集群。 ### sealos cloud云服务与sealos和k8s的关系 **Sealos Cloud** 是一个云服务平台，它使用 **Kubernetes** 作为其内核。Sealos Cloud 提供了一套强大的工具，可以便利地管理整个 Kubernetes 集群的生命周期。 **Sealos** 是一个基于Go语言开发的简单干净且Kubernetes集群部署工具。它可以帮助用户在生产环境中部署高可用的Kubernetes集群。 **Kubernetes**（简称K8s）是一个开源的容器编排系统，用于自动化部署、扩展和管理容器化应用程序。 因此，Sealos Cloud、Sealos和Kubernetes的关系可以理解为：Sealos是一个工具，它使用Kubernetes作为内核，帮助用户更方便地部署和管理Kubernetes集群。而Sealos Cloud则是一个云服务平台，它也使用Kubernetes作为内核，提供了一套强大的工具，可以便利地管理整个 Kubernetes 集群的生命周期。 ### k8s查看计算费用，计算使用内存，计算消耗等的功能 Kubernetes本身并没有直接提供查看计算费用的功能，但它提供了一些工具和API来监控和度量资源使用情况，如CPU和内存等。这些数据可以帮助我们判断容器是否过度消耗资源或存在性能瓶颈。你可以使用Kubernetes的`top`命令来查看所有Pod和Node的内存和CPU使用情况。 对于计算费用，你可能需要借助一些第三方的工具或服务。例如，Kubecost是一个开源工具，它可以提供Kubernetes集群的成本分析和报告，帮助你理解和管理集群的运行成本。 以下是一些可能需要的Kubernetes组件和工具： 1. **Metrics Server**：Metrics Server是一个集群范围的资源指标的聚合器，它被Metrics API使用。这是查看资源使用情况的基础设施。 2. **Heapster**（已被弃用）：Heapster是一个性能监控和事件数据聚合系统，它可以收集和解释各种事件和指标。 3. **Prometheus**：Prometheus是一个开源的监控和警报工具包，它可以收集和存储可靠的时间序列数据。 4. **Kubecost**：Kubecost提供了对Kubernetes资源消耗的可视化，包括CPU、内存、网络等，以及这些资源的成本。 ## Ubuntu22.04.2 k8s部署 ### 注意：Sealos内部自带有Docker一样的功能，无需重复下载docker ### 环境部署 搭建 Kubernetes (k8s) 集群的电脑配置要求如下： * **操作系统**：CentOS 7.x-86_x64 或者其他类似的 Linux 发行版。 * 硬件配置： * **CPU**：2核或更多。 * **内存**：2GB或更多。 * **硬盘**：30GB或更多。 * **网络**：集群中的所有机器之间需要网络互通。 * **外网访问**：可以访问外网，需要拉取镜像。 * **禁止swap分区**。 这些只是基本的要求，实际的配置可能需要根据你的具体需求进行调整。例如，如果你打算在集群上运行资源密集型的应用，你可能需要更多的 CPU 核心和内存。同样，如果你的应用需要大量的存储空间，你可能需要更大的硬盘。 #### 1,主机名修改不一致 查看主机名称：hostname 修改主机名 hostnamectl set-hostname k8s-master-1 #### 2,查看ip地址是否为静态ip 查看ip地址是否配置为静态ip：ip a s ens33 #### 3,修改/etc/hosts，添加以下配置 下载vim: sudo apt install vim #修改/etc/hosts，添加以下配置（ip后面的名称即为刚刚修改的主机名） sudo vim /etc/hosts > > ``` > 192.168.231.140   k8s-master01 > 192.168.231.141   k8s-worker01 > 192.168.231.142   k8s-worker02 > 192.168.231.143   k8s-worker03 > ``` #### 4,关闭防火墙 # 停止 sudo ufw disable #### 5,关闭SELinux 在Ubuntu系统中，SELinux默认是不启用的。但如果你已经启用了SELinux并希望关闭它，可以按照以下步骤操作: 1,**查看SELinux状态**：在终端中执行以下命令，查看系统中SELinux的状态： sestatus 如果SELinux已经安装并启用，你将看到类似以下输出： SELinux status: enabled 2,**临时禁用SELinux**：如果只想临时禁用SELinux，可以执行以下命令： sudo setenforce 0 这会将SELinux设置为"Permissive"模式，这意味着虽然SELinux仍然运行，但它将记录所有的安全事件而不执行任何动作。 3,**永久禁用SELinux**：如果你确定要永久禁用SELinux，需要编辑SELinux配置文件。使用以下命令打开SELinux配置文件： sudo nano /etc/selinux/config 找到以下行： SELINUX=enforcing 将其改为： SELINUX=disabled 保存并关闭文件。 4,**重新启动系统**：完成以上步骤后，重新启动系统以使更改生效： sudo reboot 或者，你可以使用以下命令暂时将SELinux置于宽容模式。请注意，此更改不会在重新启动后继续存在，并且稍后会返回到"强制"模式。要再次启用SELinux，只需执行： sudo setenforce 1 #### 6,关闭swap # 关闭swap sudo swapoff -a # 禁用开机自动启用swap sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab #### 7,设置时间同步 # 设置时区 sudo timedatectl set-timezone Asia/Shanghai ​ # 同步时间 sudo apt-get install -y ntpdate sudo ntpdate time1.aliyun.com (有网才行) ### sealos CLI部署k8s集群 #### 安装sealos 仅仅k8s-master01安装就行 下载Sealos wget https://github.com/labring/sealos/releases/download/v5.0.0-beta5/sealos_5.0.0-beta5_linux_amd64.deb 安装Sealos sudo dpkg -i sealos_5.0.0-beta5_linux_amd64.deb 验证安装 sealos version #### 部署前的准备 ##### 给root用户设置密码 > 给--masters和--nodes配置的ip的机器root用户机器设置密码 > > --masters 192.168.231.140 \\ > > --nodes 192.168.231.141,192.168.231.142,192.168.231.143 \\ > > sudo passwd root > > 111111 ##### 确保支持ssh密码认证和连接 确保你的节点支持密码认证。你可以通过在你的节点上查看/etc/ssh/sshd_config文件来确认这一点。如果这个文件中的PasswordAuthentication选项被设置为no，那么你的节点就不支持密码认证。你可以将这个选项改为yes，然后重启SSH服务来启用密码认证。 vim /etc/ssh/sshd_config **如果root用户不支持ssh连接进行如下操作** **`PermitRootLogin prohibit-password`** 这个设置表示系统禁止通过密码认证的方式来进行**`root`** 用户的SSH登录。你可以将这个设置改为**`PermitRootLogin yes`** ，这样就可以允许**`root`**用户通过密码认证的方式进行SSH登录。以下是具体的步骤： 1. 打开SSH的配置文件： sudo vim /etc/ssh/sshd_config 2. 在打开的文件中，找到`PermitRootLogin prohibit-password`这一行。 3. 将这一行改为`PermitRootLogin yes`。 4. 保存并关闭文件。 5. 重启SSH服务： sudo systemctl restart ssh 完成以上步骤后，你应该就可以使用`root`用户进行SSH连接了。 #### k8s部署依赖介绍 > ``` > labring/helm:v3.12.0 \ > labring/calico:v3.24.1 \ > labring/cert-manager:v1.8.0 \ > labring/openebs:v3.4.0 \ > ``` 这些都是 Kubernetes 集群中的重要组件，它们各自有不同的作用： 1. **labring/helm:v3.12.0**：Helm 是 Kubernetes 的一个包管理工具，类似于 Linux 下的 apt 或 yum。它可以帮助用户通过定义配置文件的方式来部署和管理 Kubernetes 应用，极大地简化了应用在 Kubernetes 上的部署和管理流程。 2. **labring/calico:v3.24.1**：Calico 是一个网络策略引擎，它提供了网络策略和网络路由的功能，可以用于 Kubernetes 集群的网络策略管理和 Pod 网络的构建。 3. **labring/cert-manager:v1.8.0**：Cert-Manager 是一个用于 Kubernetes 集群中自动化管理 TLS 证书的开源工具。它使用了 Kubernetes 的自定义资源定义（CRD）机制，让证书的创建、更新和删除变得非常容易。 4. **labring/openebs:v3.4.0**：OpenEBS 是一个开源的存储平台，它提供了一种简单的方式来部署和管理持久化数据存储在 Kubernetes 中。OpenEBS 支持多种类型的存储，包括本地卷、复制卷等。 #### 网络下部署 ##### 使用sealos cli部署K8S集群（请使用管理员权限） ###### 1，获取Clusterfile文件 > ``` > [root@k8s-master01 ~]# vim sealos-cli-install-k8s.sh > [root@k8s-master01 ~]# cat sealos-cli-install-k8s.sh > #k8s版本1.25.6 > sealos gen labring/kubernetes:v1.25.6 \ >   labring/helm:v3.12.0 \ >   labring/calico:v3.24.1 \ >   labring/cert-manager:v1.8.0 \ >   labring/openebs:v3.4.0 \ >   --masters 192.168.231.140 \ >   --nodes 192.168.231.141,192.168.231.142,192.168.231.143 \ >   -p 111111 --output Clusterfile > ​ > ​ > #k8s版本1.27.11 > sealos gen labring/kubernetes:v1.27.11 \ >   labring/helm:v3.14.1 \ >   labring/calico:v3.24.1 \ >   labring/cert-manager:v1.14.4 \ >   labring/openebs:v3.10.0 \ >   --masters 192.168.231.140 \ >   --nodes 192.168.231.141,192.168.231.142,192.168.231.143 \ >   -p 111111 --output Clusterfile > ``` > ``` > [root@k8s-master01 ~]# sh sealos-cli-install-k8s.sh > 如果执行后生成的Clusterfile有问题，下载下面依赖 > sudo apt-get install uidmap > sudo apt-get install fuse-overlayfs > ``` `sealos gen` 命令会根据你提供的参数来生成 `Clusterfile` 文件。在你的例子中，这些参数包括： * `labring/kubernetes:v1.25.6`、`labring/helm:v3.12.0`、`labring/calico:v3.24.0`、`labring/cert-manager:v1.8.0` 和 `labring/openebs:v3.4.0`：这些是你要部署的 Kubernetes 集群所需的组件和它们的版本。 * `--masters 192.168.231.140`：这是你的 Kubernetes 集群的 master 节点的 IP 地址。 * `--nodes 192.168.231.141,192.168.231.142,192.168.231.143`：这些是你的 Kubernetes 集群的 worker 节点的 IP 地址。 * `-p 111111`：这是用于 SSH 连接到你的节点的密码。 * `--output Clusterfile`：这是生成的 `Clusterfile` 文件的名称。 ###### 2，sealos利用Clusterfile部署 > ``` > 部署 > [root@k8s-master01 ~]# sealos apply -f Clusterfile > ``` **出现下图，说明k8s集群已安装完成。**  查看节点状态 > > ``` > [root@k8s-master01 ~]# kubectl get pods -A > [root@k8s-master01 ~]# kubectl get nodes > NAME           STATUS   ROLES           AGE   VERSION > k8s-master01   Ready   control-plane   18h   v1.25.6 > k8s-worker01   Ready           18h   v1.25.6 > k8s-worker02   Ready           18h   v1.25.6 > k8s-worker03   Ready           18h   v1.25.6 > ​ > kubectl get pods -A：这个命令用于获取 Kubernetes 集群中所有命名空间的 Pod 的信息。Pod 是 Kubernetes 中的最小部署单元，它包含一个或多个容器。-A 参数表示获取所有命名空间的 Pod 的信息。 > kubectl get nodes：这个命令用于获取 Kubernetes 集群中所有节点（Node）的信息。在 Kubernetes 中，节点可以是一个虚拟机或物理机，它是运行 Pod 的主机。 > ``` #### 无网络部署 ##### 使用sealos cli部署K8S集群（请使用管理员权限） ###### 1，获取Clusterfile文件 网络下执行sealos-cli-install-k8s.sh获取Clusterfile复制到离线环境中 **注意：记得更改你自己的机器ip地址和密码** > > ``` > [root@k8s-master01 ~]# vim sealos-cli-install-k8s.sh > [root@k8s-master01 ~]# cat sealos-cli-install-k8s.sh > #k8s版本1.25.6 > sealos gen labring/kubernetes:v1.25.6 \ >   labring/helm:v3.12.0 \ >   labring/calico:v3.24.1 \ >   labring/cert-manager:v1.8.0 \ >   labring/openebs:v3.4.0 \ >   --masters 192.168.231.140 \ >   --nodes 192.168.231.141,192.168.231.142,192.168.231.143 \ >   -p 111111 --output Clusterfile > ​ > ​ > #k8s版本1.27.11 > sealos gen labring/kubernetes:v1.27.11 \ >   labring/helm:v3.14.1 \ >   labring/calico:v3.24.1 \ >   labring/cert-manager:v1.14.4 \ >   labring/openebs:v3.10.0 \ >   --masters 192.168.231.140 \ >   --nodes 192.168.231.141,192.168.231.142,192.168.231.143 \ >   -p 111111 --output Clusterfile > ``` `sealos gen` 命令会根据你提供的参数来生成 `Clusterfile` 文件。在你的例子中，这些参数包括： * `labring/kubernetes:v1.25.6`、`labring/helm:v3.12.0`、`labring/calico:v3.24.0`、`labring/cert-manager:v1.8.0` 和 `labring/openebs:v3.4.0`：这些是你要部署的 Kubernetes 集群所需的组件和它们的版本。 * `--masters 192.168.231.140`：这是你的 Kubernetes 集群的 master 节点的 IP 地址。 * `--nodes 192.168.231.141,192.168.231.142,192.168.231.143`：这些是你的 Kubernetes 集群的 worker 节点的 IP 地址。 * `-p 111111`：这是用于 SSH 连接到你的节点的密码。 * `--output Clusterfile`：这是生成的 `Clusterfile` 文件的名称。 ###### 2，下载部署需要的镜像 > ``` > #一键下载镜像的脚步pull_images.sh为拉取镜像后保存，save_images.sh为你已经拉取完镜像后保存 > #!/bin/bash > # pull_images.sh > set -ex > mkdir -p tars > images=( > docker.io/labring/kubernetes:v1.25.6 > docker.io/labring/helm:v3.12.0 > docker.io/labring/calico:v3.24.1 > docker.io/labring/cert-manager:v1.8.0 > docker.io/labring/openebs:v3.4.0 > docker.io/labring/kubernetes-reflector:v7.0.151 > docker.io/labring/ingress-nginx:v1.5.1 > docker.io/labring/zot:v1.4.3 > docker.io/labring/kubeblocks:v0.5.3 > docker.io/labring/sealos-cloud:latest > ) > ​ > for image in "${images[@]}"; do > sealos pull "$image" > filename=$(echo "$image" | cut -d':' -f1 | tr / -) > sealos save -o "tars/${filename}.tar" "$image" > done > ​ > #!/bin/bash > # save_images.sh > set -ex > mkdir -p tars > images=( > registry.cn-shanghai.aliyuncs.com/labring/sealos-cloud:v5.0.0-beta5 > ghcr.io/labring/sealos-cloud-template-frontend:latest > ghcr.io/labring/sealos-cloud-terminal-frontend:latest > ghcr.io/labring/sealos-cloud-applaunchpad-frontend:latest > ghcr.io/labring/sealos-cloud-desktop-frontend:latest > ghcr.io/labring/sealos-cloud-dbprovider-frontend:latest > ghcr.io/labring/sealos-cloud-cronjob-frontend:latest > ghcr.io/labring/sealos-cloud-costcenter-frontend:latest > ghcr.io/labring/sealos-cloud-license-frontend:latest > ghcr.io/labring/sealos-cloud-terminal-controller:latest > ghcr.io/labring/sealos-cloud-user-controller:latest > ghcr.io/labring/sealos-cloud-resources-controller:latest > ghcr.io/labring/sealos-cloud-job-init-controller:latest > ghcr.io/labring/sealos-cloud-license-controller:latest > ghcr.io/labring/sealos-cloud-job-heartbeat-controller:latest > ghcr.io/labring/sealos-cloud-app-controller:latest > ghcr.io/labring/sealos-cloud-account-controller:latest > registry.cn-shanghai.aliyuncs.com/labring/kubernetes:v1.27.11 > ghcr.io/labring/sealos-cloud-account-service:latest > ghcr.io/labring/sealos-cloud-database-service:latest > ghcr.io/labring/sealos-cloud-launchpad-service:latest > registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-apecloud-mysql:v0.8.2 > registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-postgresql:v0.8.2 > registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-mongodb:v0.8.2 > registry.cn-shanghai.aliyuncs.com/labring/kubeblocks:v0.8.2 > registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-redis:v0.8.2 > registry.cn-shanghai.aliyuncs.com/labring/cockroach:latest > registry.cn-shanghai.aliyuncs.com/labring/cilium:v1.14.8 > registry.cn-shanghai.aliyuncs.com/labring/cert-manager:v1.14.4 > registry.cn-shanghai.aliyuncs.com/labring/openebs:v3.10.0 > registry.cn-shanghai.aliyuncs.com/labring/helm:v3.14.1 > registry.cn-shanghai.aliyuncs.com/labring/victoria-metrics-k8s-stack:v1.96.0 > registry.cn-shanghai.aliyuncs.com/labring/ingress-nginx:v1.9.4 > registry.cn-shanghai.aliyuncs.com/labring/metrics-server:v0.6.4 > ) > ​ > for image in "${images[@]}"; do > filename=$(echo "$image" | cut -d':' -f1 | tr / -) > sealos save -o "tars/${filename}.tar" "$image" > done > ​ > #一键加载镜像的脚步 > #!/bin/bash > # load_images.sh > set -ex > for file in tars/*.tar; do > sealos load -i "$file" > done > ``` ###### 详细步骤解析 在有网络的环境中，使用 `sealos save` 命令导出 Docker 镜像。例如： > > ``` > sealos save -o <保存的路径> <镜像名>:<标签> > ``` 例子： * sealos save -o ./kubernetes1.25.6.tar docker.io/labring/kubernetes:v1.25.6 * sealos save -o ./cert-manager1.8.0.tar docker.io/labring/cert-manager:v1.8.0 * sealos save -o ./helm3.12.0.tar docker.io/labring/helm:v3.12.0 * sealos save -o ./openebs3.4.0.tar docker.io/labring/openebs:v3.4.0 * sealos save -o ./calico3.24.1.tar docker.io/labring/calico:v3.24.1 将导出的 Docker 镜像文件复制到离线环境中。 在离线环境中，使用 `sealos load` 命令导入 Docker 镜像。例如： > > ``` > sealos load -i <镜像文件路径> > ``` 例子： * sealos load -i ./calico3.24.1.tar * sealos load -i ./cert-manager1.8.0.tar * sealos load -i ./openebs3.4.0.tar * sealos load -i ./kubernetes1.25.6.tar * sealos load -i ./helm3.12.0.tar 确认镜像已经成功导入，可以使用 `sealos images` 命令查看。 ###### 3，sealos利用Clusterfile部署 你可以按照之前的步骤使用 Sealos 部署 Kubernetes。例如： > > ``` > sealos apply -f Clusterfile > ``` 请注意，你需要替换上述命令中的 `<保存的路径>`、`<镜像名>:<标签>` 和 `<镜像文件路径>` 为实际的值。 **出现下图，说明k8s集群已安装完成。**  查看节点状态 > > ``` > [root@k8s-master01 ~]# kubectl get pods -A > [root@k8s-master01 ~]# kubectl get nodes > NAME           STATUS   ROLES           AGE   VERSION > k8s-master01   Ready   control-plane   18h   v1.25.6 > k8s-worker01   Ready           18h   v1.25.6 > k8s-worker02   Ready           18h   v1.25.6 > k8s-worker03   Ready           18h   v1.25.6 > ​ > kubectl get pods -A：这个命令用于获取 Kubernetes 集群中所有命名空间的 Pod 的信息。Pod 是 Kubernetes 中的最小部署单元，它包含一个或多个容器。-A 参数表示获取所有命名空间的 Pod 的信息。 > kubectl get nodes：这个命令用于获取 Kubernetes 集群中所有节点（Node）的信息。在 Kubernetes 中，节点可以是一个虚拟机或物理机，它是运行 Pod 的主机。 > ``` ### nginx应用运行例子 #### 有网例子 > ``` > # 创建一次deployment部署 > kubectl create deployment nginx --image=nginx #有网络请使用 > kubectl expose deployment nginx --port=80 --type=NodePort > # 查看Nginx的pod和service信息 > kubectl get pod,svc -o wide > ``` #### 无网例子 无网络情况下可提前在有网的情况下下载镜像，然后**sealos load -i \<镜像文件路径\>** 使用Sealos的`login`命令： > > ``` > sealos login -u admin -p passw0rd 192.168.231.140:5000 > ``` **推送镜像到Registry** ：然后，你可以将你的Docker镜像推送到你的私人Registry。首先，你需要给你的镜像打上标签，然后推送它。例如，如果你有一个名为`my-image`的镜像，你可以使用以下命令： > > ``` > sealos tag nginx 192.168.231.140:5000/my_nginx > sealos push 192.168.231.140:5000/my_nginx > ``` > ``` > # 创建一次deployment部署 > kubectl create deployment nginx --image=192.168.231.140:5000/my_nginx #无网络请使用 > kubectl expose deployment nginx --port=80 --type=NodePort > # 查看Nginx的pod和service信息 > kubectl get pod,svc -o wide > ``` ### 应用部署   #### 资源对象扩容缩容 > ``` > kubectl edit deployment.apps nginx > ``` 这个命令 `kubectl edit deployment.apps nginx` 是 Kubernetes 的命令行工具 `kubectl` 的一个命令。下面是对这个命令的解析和备注： * `kubectl`: 这是 Kubernetes 的命令行工具，用于与 Kubernetes 集群进行交互。 * `edit`: 这是 `kubectl` 的一个子命令，用于编辑 Kubernetes 集群中的资源。 * `deployment.apps`: 这是要编辑的资源类型。在这个例子中，资源类型是 `deployment.apps`，表示我们要编辑的是一个 Deployment 资源。 * `nginx`: 这是要编辑的资源的名称。在这个例子中，资源的名称是 `nginx`，表示我们要编辑的是名为 `nginx` 的 Deployment。 运行命令打开文件修改replicas数量为3实现扩容  结果  > > ``` > kubectl scale deployment nginx --replicas=1 > ``` 这个命令 `kubectl scale deployment nginx --replicas=1` 也是 Kubernetes 的命令行工具 `kubectl` 的一个命令。下面是对这个命令的解析和备注： * `kubectl`: 这是 Kubernetes 的命令行工具，用于与 Kubernetes 集群进行交互。 * `scale`: 这是 `kubectl` 的一个子命令，用于改变 Kubernetes 集群中的资源的规模。 * `deployment`: 这是要改变规模的资源类型。在这个例子中，资源类型是 `deployment`，表示我们要改变的是一个 Deployment 的规模。 * `nginx`: 这是要改变规模的资源的名称。在这个例子中，资源的名称是 `nginx`，表示我们要改变的是名为 `nginx` 的 Deployment 的规模。 * `--replicas=1`: 这是 `scale` 命令的一个参数，用于指定新的规模。在这个例子中，`--replicas=1` 表示我们要将 `nginx` 的 Deployment 的副本数设置为 1。 结果  #### kubectl set `kubectl set` 是 Kubernetes 的命令行工具 `kubectl` 的一个子命令，用于改变 Kubernetes 集群中的资源的某些属性。下面是一些常见的 `kubectl set` 的用法： * `kubectl set image`: 用于更新 pod 模板的镜像。例如，`kubectl set image deployment/nginx nginx=nginx:1.9.1` 命令会将名为 `nginx` 的 Deployment 的 nginx 容器的镜像更新为 `nginx:1.9.1`。 * `kubectl set resources`: 用于更新资源的资源限制。例如，`kubectl set resources deployment nginx --limits=cpu=200m,memory=512Mi` 命令会将名为 `nginx` 的 Deployment 的 CPU 限制设置为 200m，内存限制设置为 512Mi。 * `kubectl set env`: 用于更新资源的环境变量。例如，`kubectl set env deployment/nginx DOMAIN=cluster` 命令会将名为 `nginx` 的 Deployment 的环境变量 `DOMAIN` 设置为 `cluster`。 * `kubectl set serviceaccount`: 用于更新资源的服务账户。例如，`kubectl set serviceaccount deployment nginx sa-nginx` 命令会将名为 `nginx` 的 Deployment 的服务账户设置为 `sa-nginx`。 这些只是 `kubectl set` 的一些常见用法，还有很多其他的用法。你可以使用 `kubectl set --help` 命令来获取更多的信息和示例。在使用 `kubectl set` 命令时，需要注意，不是所有的属性都可以通过 `set` 命令来改变，有些属性可能需要使用 `edit` 命令或者其他的命令来改变。所以在使用这个命令时，需要根据你的需求来选择合适的命令。同时，`kubectl set` 命令的更改会立即应用，所以在使用这个命令时，需要谨慎操作。如果你不确定一个命令的效果，你可以先在一个测试环境中试验这个命令，确认没有问题后再在生产环境中使用。这是一个很好的实践，可以帮助你避免因为错误的命令导致的问题。 #### 命名空间 -- k8s平台上的一个独立的小房间，每个房间的资源，互相独立。 namespace，如果杀死命名空间，命名空间其下的所有资源（如 Pod、Service、Deployment 等）都将被删除。 ##### **查看命令** > ``` > kubectl get pods > kubectl get ns > kubectl get pod -n default > ``` 这三个命令都是 Kubernetes 的命令行工具 `kubectl` 的命令，用于获取 Kubernetes 集群中的资源信息。下面是对这些命令的解析和备注： 1. `kubectl get pods`: 这个命令用于获取 Kubernetes 集群中的所有 Pod 的信息。Pod 是 Kubernetes 中的最小部署单元，每个 Pod 可以包含一个或多个容器。这个命令会列出所有的 Pod，包括它们的名称、状态、重启次数和运行时间等信息。 2. `kubectl get ns`: 这个命令用于获取 Kubernetes 集群中的所有命名空间（Namespace）的信息。命名空间是 Kubernetes 中用于将资源进行逻辑隔离的一种方式。这个命令会列出所有的命名空间，包括它们的名称和状态等信息。 3. `kubectl get pod -n default`: 这个命令用于获取 Kubernetes 集群中 `default` 命名空间下的所有 Pod 的信息。`-n default` 参数指定了命名空间为 `default`。这个命令会列出 `default` 命名空间下的所有 Pod，包括它们的名称、状态、重启次数和运行时间等信息。 这些命令都是 Kubernetes 管理员在日常工作中经常使用的命令，用于查看和管理 Kubernetes 集群中的资源。 ##### **示例** 以下是一个示例的 YAML 文件，它首先创建一个名为 `my-namespace` 的命名空间，然后在该命名空间中部署一个 nginx 应用： > > ``` > # 这部分定义了一个 Namespace（命名空间）资源 > --- > apiVersion: v1  # Kubernetes API 的版本 > kind: Namespace  # 资源类型，这里是 Namespace > metadata: > name: my-namespace  # Namespace 的名称 > ​ > # 这部分定义了一个 Deployment（部署）资源 > --- > apiVersion: apps/v1  # Kubernetes API 的版本 > kind: Deployment  # 资源类型，这里是 Deployment > metadata: > name: nginx-deployment  # Deployment 的名称 > namespace: my-namespace  # Deployment 所在的 Namespace > spec: > selector: >   matchLabels: >     app: nginx  # 选择器，用于选择属于这个 Deployment 的 Pod > replicas: 1  # 副本数，表示这个 Deployment 管理的 Pod 的数量 > template:  # Pod 模板，用于创建新的 Pod >   metadata: >     labels: >       app: nginx  # 标签，会被添加到所有由这个 Deployment 创建的 Pod 上 >   spec: >     containers:  # 容器列表，每个 Pod 可以包含一个或多个容器 >     - name: nginx  # 容器的名称 >       image: 192.168.231.140:5000/my_nginx  # 容器的镜像 >       ports:  # 容器的端口列表 >       - containerPort: 80  # 容器的端口号 > ​ > ``` 这个 YAML 文件包含二部分： 1. 创建一个名为 `my-namespace` 的命名空间。 2. 在 `my-namespace` 命名空间中创建一个名为 `nginx-deployment` 的 Deployment。这个 Deployment 包含一个副本，每个副本运行一个 nginx 容器。 你可以将这个 YAML 文件保存为一个 `.yaml` 文件，然后使用 `kubectl apply -f [文件名].yaml` 命令来应用这个 YAML 文件。这将会创建命名空间和 nginx 应用。 **运行结果**  ##### 删除命名空间，删除命名空间中的某个特定资源 **删除命名空间** > > > kubectl delete namespace server > \`kubectl delete namespace server\`: 这个命令用于删除 Kubernetes 集群中名为 \`server\` 的命名空间。当你执行这个命令时，\`server\` 命名空间及其下的所有资源（如 Pod、Service、Deployment 等）都将被删除。这是一个破坏性的操作，一旦执行，所有的数据都将被永久删除，无法恢复。因此，在执行这个命令之前，你需要确保你真的想要删除这个命名空间及其所有资源。 **删除某个特定资源** 在 Kubernetes 中，你可以使用 \`kubectl delete\` 命令来删除命名空间中的特定资源。你需要提供要删除的资源类型和资源名称，以及资源所在的命名空间。以下是一些示例： - 删除默认命名空间中的 Pod： > kubectl delete pod my-pod - 删除特定命名空间中的 Deployment： > kubectl delete deployment my-deployment -n my-namespace 在这些命令中，\`my-pod\` 和 \`my-deployment\` 是要删除的资源的名称，\`my-namespace\` 是资源所在的命名空间。 \*在使用这些命令时，你需要注意，这些命令只能删除资源，不能恢复已经删除的资源。如果你不小心删除了一个重要的资源，你可能需要重新创建这个资源，或者从备份中恢复这个资源（如果你有备份的话）。因此，在使用这些命令时，你需要谨慎操作，确保你知道这些命令的影响，并且你已经做好了相应的准备。\* #### Service ##### service简介 作用：将外部流量引入到pod里面 关键：label（通过label去引入的） 地址：clusterIp -- 虚拟网络 ====》k8s集群外部的主机是无法访问的 k8s集群内部的所有应用对象，都可以自由访问  service更多详细介绍参考：[玩转k8s：Service详解-CSDN博客](https://blog.csdn.net/duansamve/article/details/129613829 "玩转k8s：Service详解-CSDN博客") ##### **查看service** > ``` > kubectl get svc > kubectl describe svc nginx > kubectl get pod -o wide > ``` 1. `kubectl get pod -o wide`: 这个命令用于获取 Kubernetes 集群中的所有 Pod 的详细信息。`-o wide` 参数表示输出详细的信息，包括每个 Pod 的 IP 地址、所在的节点等。 2. `kubectl describe svc nginx`: 这个命令用于获取 Kubernetes 集群中名为 `nginx` 的 Service 的详细描述信息。这个命令的输出包括 Service 的类型、端口映射、选择器、事件等信息。 3. `kubectl get svc`: 这个命令用于获取 Kubernetes 集群中的所有 Service 的信息。Service 是 Kubernetes 中的一种资源，用于提供网络服务，如 HTTP 服务、数据库服务等。 ##### 创建service ###### 集群外部用户访问集群内部pod应用 命令方式： expose > kubectl expose --help #查看帮助文档 > > kubectl expose deployment nginx --port=80  yaml清单文件方式：apply kubectl expose deployment nginx --port=8080 --dry-run=client -o yaml \> nginx_service.yaml > > ``` > #nginx_service.yaml文件修改前 > apiVersion: v1 > kind: Service > metadata: > creationTimestamp: null > labels: >   app: nginx > name: nginx > spec: > ports: > - port: 8080 >   protocol: TCP >   targetPort: 8080 > selector: >   app: nginx > status: > loadBalancer: {} >   > #nginx_service.yaml文件修改后 > apiVersion: v1 > kind: Service > metadata: > labels: >   app: nginx > name: nginx > spec: > ports: > - port: 8080 >   protocol: TCP >   targetPort: 80 > selector: >   app: nginx > ``` 在这个 Kubernetes Service 配置中： * `port: 8080` 是**向外暴露的端口**（也被称为服务端口）。这是其他服务或客户端在集群内部访问这个 Service 时使用的端口。 * `targetPort: 8080` 是**容器的 Pod 端口**。这是 Service 将流量路由到的 Pod 中的容器端口。 apply运行 > > ``` > kubectl apply -f nginx_service.yaml > kubectl get svc > ``` ###### 集群内部pod应用访问集群外部服务 ###### 详细步骤 1. 部署外部集群 2. 创建endpoint 3. 创建service 4. pod测试 ###### 部署外部集群 部署外部mysql环境 > > ``` > # 更新系统软件包 > sudo apt-get update > ​ > # 安装 MariaDB 服务器 > sudo apt-get install mariadb-server -y > ​ > # 启动 MariaDB 服务 > sudo systemctl start mariadb > ​ > # 设置 MariaDB 服务在启动时自动启动 > sudo systemctl enable mariadb > ​ > 开启 MySQL 服务器远程访问能力 > sudo vim /etc/mysql/mariadb.conf.d/50-server.cnf > 在 vim 中，你需要先按 i 键进入插入模式，才能开始编辑文本。 > 找到 [mysqld] 部分，然后找到 bind-address，将其值改为 0.0.0.0： > [mysqld] > bind-address = 0.0.0.0 > ​ > 重启 MySQL 服务使配置生效 > sudo systemctl restart mariadb > ​ > 配置远程主机登录权限 > mysql -uroot -p123456 -e "GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;" > mysql -uroot -p123456 -e "FLUSH PRIVILEGES;" > 主库上创建数据库 > ]# mysql -uroot -p123456" > CREATE DATABASE bookinfo default charset utf8 collate utf8_general_ci; > USE bookinfo; > CREATE TABLE book_info ( >  id INT AUTO_INCREMENT PRIMARY KEY, >  book_name VARCHAR(100), >  author VARCHAR(100), >  date_of_issue DATE, >  isDelete BOOLEAN > ); > INSERT INTO book_info (book_name, author, date_of_issue, isDelete) VALUES >  ('Book 1', 'Author 1', '2022-01-01', FALSE), >  ('Book 2', 'Author 2', '2022-02-01', FALSE), >  ('Book 3', 'Author 3', '2022-03-01', TRUE); > use bookinfo > select * from book_info; > 检查是否可以远程连接 > mysql -uroot -p123456 -h192.168.231.141 -e "show databases" > ``` 定制资源清单文件 > > ``` > # 创建一个名为 'external-ns' 的命名空间 > apiVersion: v1 > kind: Namespace > metadata: > name: external-ns > ​ > --- > ​ > # 创建一个名为 'ex-mysql' 的 Endpoints 对象，它定义了一个 IP 地址和一个端口 > # 这通常用于表示一个非 Kubernetes 服务的网络端点 > apiVersion: v1 > kind: Endpoints > metadata: > name: ex-mysql > namespace: external-ns > subsets: > - addresses: >     - ip: 10.0.0.18 # IP 地址 >   ports: >     - port: 3306 # 端口 > ​ > --- > ​ > # 创建一个名为 'ex-mysql' 的 Service 对象 > # 这个 Service 对象定义了一个 ClusterIP 类型的服务，端口为 3306，目标端口也为 3306 > # 这个服务可以用于在集群内部访问 'ex-mysql' Endpoints 对象所代表的网络端点 > apiVersion: v1 > kind: Service > metadata: > name: ex-mysql > namespace: external-ns > spec: > type: ClusterIP > ports: > - port: 3306 >   targetPort: 3306 > ​ > --- > ​ > # 创建一个名为 'bookinfo' 的 Deployment 对象 > # 这个 Deployment 对象定义了一个副本数为 1 的 Pod，Pod 中运行了一个名为 'flask-bookinfo' 的容器 > # 该容器使用的镜像是 'kubernetes-register.sswang.com/sswang/flask_bookinfo:2.3.2' > # 容器的端口是 5000，环境变量包括数据库主机名、用户名、密码和数据库名，这些都用于连接到 'ex-mysql' 服务 > apiVersion: apps/v1 > kind: Deployment > metadata: > name: bookinfo > namespace: external-ns > spec: > replicas: 1 > selector: >   matchLabels: >     app: flask-bookinfo > template: >   metadata: >     labels: >       app: flask-bookinfo >   spec: >     containers: >       - name: flask-bookinfo >         image: kubernetes-register.sswang.com/sswang/flask_bookinfo:2.3.2 >         imagePullPolicy: Always >         ports: >           - containerPort: 5000 >         env: >           - name: DB_HOST >             value: "ex-mysql" # 数据库主机名 >           - name: DB_USER >             value: "root" # 数据库用户名 >           - name: DB_PASSWORD >             value: "123456" # 数据库密码 >           - name: DB_DATABASE >             value: "bookinfo" # 数据库名 > ​ > ``` 结果 > > ``` > 查看 > kubectl get pod -n external-ns > 端口转发 > kubectl -n external-ns port-forward --address 0.0.0.0 pod/bookinfo 5000:5000 > ``` 这个命令是 Kubernetes 的 `kubectl` 命令，用于在本地机器和 Kubernetes 集群中的 Pod 之间建立网络端口转发。下面是对这个命令的详细解析： * `kubectl`：这是 Kubernetes 的命令行工具，用于管理 Kubernetes 集群。 * `-n external-ns`：这个选项指定了命名空间为 `external-ns`。命名空间是 Kubernetes 中用于将资源进行逻辑隔离的。 * `port-forward`：这是 `kubectl` 的一个子命令，用于在本地机器和 Kubernetes 集群中的 Pod 之间建立网络端口转发。 * `--address 0.0.0.0`：这个选项指定了本地地址为 `0.0.0.0`，这意味着会监听所有的网络接口。 * `pod/bookinfo`：这是要进行端口转发的 Pod 的名称，格式为 `<资源类型>/<资源名称>`。 * `5000:5000`：这是端口转发的设置，格式为 `<本地端口>:`。这意味着本地的 5000 端口会被转发到 Pod 的 5000 端口。 总的来说，这个命令的作用是将本地机器的 5000 端口转发到 `external-ns` 命名空间中名为 `bookinfo` 的 Pod 的 5000 端口，从而可以通过访问本地的 5000 端口来访问该 Pod 的服务。  ###### 错误处理 root@k8s-master01:\~# mysql -uroot -p123456 -h192.168.231.141 -e "show databases" Command 'mysql' not found, but can be installed with: apt install mysql-client-core-8.0 # version 8.0.35-0ubuntu0.22.04.1, or apt install mariadb-client-core-10.6 # version 1:10.6.12-0ubuntu0.22.04.1 这个错误表明你的系统中没有安装 `mysql` 客户端。你可以通过以下命令来安装： 如果你想安装 MySQL 客户端，可以使用以下命令： > > ``` > sudo apt install mysql-client-core-8.0 > ``` 如果你想安装 MariaDB 客户端，可以使用以下命令： > > ``` > sudo apt install mariadb-client-core-10.6 > ``` 安装完成后，你应该就可以使用 `mysql` 命令来连接到你的 MariaDB 服务器了。 ##### 删除service 在 Kubernetes 中，你可以使用 `kubectl delete service` 命令来删除一个 Service。你需要提供要删除的 Service 的名称，以及（可选的）Service 所在的命名空间。如果 Service 在默认命名空间中，你可以省略命名空间。 以下是一些示例： * 删除默认命名空间中的 Service： > ``` > kubectl delete service my-service > ``` * 删除特定命名空间中的 Service： > ``` > kubectl delete service my-service -n my-namespace > ``` 在这些命令中，`my-service` 是要删除的 Service 的名称，`my-namespace` 是 Service 所在的命名空间。 请注意，删除 Service 不会删除后端的 Pod。这意味着，即使 Service 被删除，后端的 Pod 仍然会运行，除非你明确地删除它们。 ### k8s查看计算费用，计算使用内存等的功能 #### Metrics-Server Metrics-Server是Kubernetes的一个核心组件，它用于收集和提供集群范围内的资源使用数据。Metrics-Server实现了Resource Metrics API，从每个节点上的Kubelet公开的Summary API中采集指标信息。 Metrics-Server的主要功能包括： * **提供资源使用数据**：Metrics-Server可以提供关于节点和Pod的当前CPU、内存和存储的资源使用情况。 * **支持其他Kubernetes组件** ：一些Kubernetes组件，如`kubectl top`和Horizontal Pod Autoscaler (HPA)，依赖于Metrics API来获取资源使用数据。 需要注意的是，Metrics-Server只能提供当前的资源使用情况，而无法提供历史数据。如果你需要历史数据，可能需要考虑使用其他的监控和度量解决方案，如Prometheus等。 **Metrics-Server组件目的**：获取集群中pod，节点等负载信息 参考连接：[资源指标管道 \| Kubernetes](https://kubernetes.io/zh-cn/docs/tasks/debug/debug-cluster/resource-metrics-pipeline/ "资源指标管道 | Kubernetes")  ##### 兼容性矩阵 | 指标服务器 | 指标 API 组/版本 | 支持的 Kubernetes 版本 | |-------|--------------------------|-------------------| | 0.7.x | `metrics.k8s.io/v1beta1` | 1.19+ | | 0.6.x | `metrics.k8s.io/v1beta1` | 1.19+ | | 0.5.x | `metrics.k8s.io/v1beta1` | \*1.8+ | | 0.4.x | `metrics.k8s.io/v1beta1` | \*1.8+ | | 0.3.x | `metrics.k8s.io/v1beta1` | 1.8-1.21 | ##### Metrics Server 下载方式 github：[https://github.com/kubernetes-sigs/metrics-server](https://github.com/kubernetes-sigs/metrics-server "https://github.com/kubernetes-sigs/metrics-server") ##### k8s集群安装部署metrics(高可用性安装) 使用高可用性（High Availability）的`metrics-server`配置相比普通配置有以下优势： * **快速的自动扩缩**：每15秒收集一次度量，使得Kubernetes能够更快地进行自动扩缩。 * **资源效率**：对于每个集群节点，只使用1毫核的CPU和2MB的内存。 * **可扩展性**：支持最多5000个节点的集群。 * **单一部署**：在大多数集群上都可以工作。 这些优势使得`metrics-server`能够在大规模和高负载的环境中提供稳定和可靠的性能 ###### 下载  ###### 下载地址 > ``` > 下载地址：https://github.com/kubernetes-sigs/metrics-server/releases > wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/high-availability-1.21+.yaml > ``` metrics阿里云镜像地址： registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server:v0.7.1 docker镜像地址： docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server:v0.7.1 用sealos自带的docker: sealos pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-server:v0.7.1 ###### 修改high-availability-1.21+.yaml  ###### 执行部署 > ``` > kubectl apply -f ./high-availability-1.21+.yaml > ``` ###### 查看metrics-server的pod运行状态 > ``` > kubectl get pods -n kube-system| egrep 'NAME|metrics-server' > ``` ### 一些基本的`kubectl`命令： **查看资源** ：你可以使用`kubectl get`命令来查看Kubernetes集群中的资源。例如，要查看所有的Pods，你可以使用以下命令： > > ``` > kubectl get pods > ``` **查看详情** ：你可以使用`kubectl describe`命令来查看资源的详细信息。例如，要查看名为`my-python-app`的Pod的详细信息，你可以使用以下命令： > > ``` > kubectl describe pod my-python-app > ``` **创建资源** ：你可以使用`kubectl apply`命令来创建或更新资源。例如，要根据`my-python-app.yaml`文件创建资源，你可以使用以下命令： > > ``` > kubectl apply -f my-python-app.yaml > ``` **删除资源** ：你可以使用`kubectl delete`命令来删除资源。例如，要删除名为`my-python-app`的Pod，你可以使用以下命令： > > ``` > kubectl delete pod my-python-app > ``` **查看日志** ：你可以使用`kubectl logs`命令来查看Pod的日志。例如，要查看名为`my-python-app`的Pod的日志，你可以使用以下命令： > > ``` > kubectl logs my-python-app > ``` 以上只是`kubectl`的一些基本操作，`kubectl`还有许多其他的命令和选项。 ### Sealos私有云部署一键部署 详细参考：[Sealos 集群部署 \| Sealos: 专为云原生开发打造的以 K8s 为内核的云操作系统](https://sealos.run/docs/self-hosting/sealos/installation "Sealos 集群部署 | Sealos: 专为云原生开发打造的以 K8s 为内核的云操作系统")     ## docker安装 ### docker介绍 Docker是一种开源的应用容器引擎，它允许开发者将应用及其依赖打包到一个可移植的容器中，然后发布到任何流行的Linux机器或Windows机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。 让我们用一个简单的比喻来理解Docker的作用： 想象你正在搬家，你需要把你的所有物品（你的代码和它的依赖）打包到箱子里（Docker容器）。这样，无论你搬到哪个新房子（新的服务器或电脑），你的物品都能够正常工作，因为它们都在你的箱子里，和外部环境隔离开来。 Docker的主要作用有： 1. **环境一致性**：无论开发、测试还是生产环境，Docker都能保证环境的一致性，避免了"在我机器上可以运行"的问题。 2. **快速部署**：Docker可以快速地启动容器（通常在几秒钟内），使得应用的部署、扩展和迁移变得更加高效。 3. **持续交付和部署**：使用Docker，你可以构建一个容器来运行你的应用，然后把这个容器发布出去。其他人可以直接使用你的容器来运行应用，无需关心环境问题。 4. **隔离性**：每个Docker容器都运行在自己的环境中，互不干扰。 5. **微服务架构**：Docker非常适合用来部署和运行基于微服务架构的应用。 总的来说，Docker就像一个轻量级的"虚拟机"，它改变了软件开发和部署的方式，使得这个过程变得更加高效、灵活和可靠。 注意：如果要使用docker请用sealos安装支持docker的k8s，否则直接用sealos即可 [安装 K8s 集群 \| Sealos: 专为云原生开发打造的以 K8s 为内核的云操作系统](https://sealos.run/docs/self-hosting/lifecycle-management/quick-start/deploy-kubernetes "安装 K8s 集群 | Sealos: 专为云原生开发打造的以 K8s 为内核的云操作系统")  docker参考资料： [几张图帮你理解 docker 基本原理及快速入门 - 一天不进步，就是退步 - 博客园](https://www.cnblogs.com/davidwang456/articles/9578409.html "几张图帮你理解 docker 基本原理及快速入门 - 一天不进步，就是退步 - 博客园") [docker 的八大技术架构(图解)_docker 架构-CSDN博客](https://blog.csdn.net/m0_73740682/article/details/136936927 "docker 的八大技术架构(图解)_docker 架构-CSDN博客") ### Docker架构 Docker使用C/S架构，Client 通过接口与Server进程通信实现容器的构建，运行和发布。client和server可以运行在同一台集群，也可以通过跨主机实现远程通信。  ### docker和sealos  ### 有网络下载 阿里云 Docker 镜像源安装 Docker 的步骤： 1. 更新包管理器： > ``` > sudo apt update > ``` 2. 安装 Docker 的依赖包： > ``` > sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release > ``` 3. 添加阿里云 Docker 镜像源 GPG 密钥： > ``` > curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg > ``` 4. 添加阿里云 Docker 镜像源： > ``` > echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null > ``` 注意：如果你使用的是非 Ubuntu 系统，比如 Debian 或 CentOS，可以参考阿里云 Docker 官方文档提供的相应命令。 5. 更新 apt 缓存： > ``` > sudo apt update > ``` 6. 安装 Docker： > ``` > sudo apt install docker-ce docker-ce-cli containerd.io > ``` 7. 启动 Docker 服务： > ``` > sudo systemctl start docker > ``` ### docker搭建一个私有仓库 **注意：我们使用sealos CLI部署k8s是存在一个有一个私有仓库端口为5000** 要在Docker中搭建一个私人镜像仓库，你可以使用Docker Registry。以下是一些步骤： **安装Docker Registry**：首先，你需要在你的服务器上安装Docker Registry。你可以使用以下命令来拉取并运行它： > > ``` > docker run -d -p 5000:5000 --restart=always --name registry registry:2 > ``` **推送镜像到Registry** ：然后，你可以将你的Docker镜像推送到你的私人Registry。首先，你需要给你的镜像打上标签，然后推送它。例如，如果你有一个名为`my-image`的镜像，你可以使用以下命令： > > ``` > docker tag my-image localhost:5000/my-image > docker push localhost:5000/my-image > ``` **从Registry拉取镜像** ：你可以使用`docker pull`命令从你的私人Registry中拉取镜像。例如： > > ``` > docker pull localhost:5000/my-image > ``` 请注意，这只是在单个服务器上运行私人Registry的基本设置。在生产环境中，你可能需要考虑使用SSL来保护你的Registry，并配置存储后端以持久化你的镜像。你可以在Docker Registry的官方文档中找到更多信息。 ### docker打包python项目，并用k8s部署 #### 撰写一个简单的flask项目  **app.py**  from flask import Flask app = Flask(__name__) ​ @app.route('/') def hello_world(): return 'Hello, World!' ​ if __name__ == '__main__': app.run(host='0.0.0.0', port=80) **Dockerfile**用于构建docker镜像  # Dockerfile FROM python:3.8-slim # 安装依赖 RUN pip install flask # 设置工作目录 WORKDIR /app # 复制代码 COPY . /app # 暴露端口 #EXPOSE 8000 # 启动命令 CMD ["python", "app.py"] service.yaml  # service.yaml apiVersion: v1 # 使用的Kubernetes API的版本 kind: Service # 资源类型，这里是Service metadata: name: my-python-app-service # Service的名称 spec: selector: app: my-python-app # 选择器，用于匹配Pod的标签 ports: # 端口配置 - protocol: TCP # 协议类型 port: 80 # Service的端口 targetPort: 80 # Pod的端口 type: LoadBalancer # Service的类型，这里是LoadBalancer deployment.yaml  # deployment.yaml apiVersion: apps/v1 # 使用的Kubernetes API的版本 kind: Deployment # 资源类型，这里是Deployment metadata: name: my-python-app # Deployment的名称 spec: replicas: 3 # 副本数量，即Pod的数量 selector: matchLabels: app: my-python-app # 选择器，用于匹配Pod的标签 template: # Pod的模板 metadata: labels: app: my-python-app # Pod的标签 spec: containers: # 容器列表 - name: my-python-app # 容器名称 image: 192.168.231.140:5000/my-app:latest # 容器镜像 ports: - containerPort: 80 # 容器开放的端口 将my_python_project目录移动到linux系统下，在my_python_project目录下执行 > > ``` > # 构建镜像 > docker build -t my_python_app . > # 标记镜像 > docker tag my_python_app localhost:5000/my-app > # 推送到远程仓库 > docker push localhost:5000/my-app > # 创建Deployment > kubectl apply -f kubernetes/deployment.yaml > # 创建Service > kubectl apply -f kubernetes/service.yaml > ``` 现在，你的镜像已经存储在你的私人Registry中，你可以在任何有权访问该Registry的地方拉取和使用它。 ### 常见错误处理 #### docker push错误 ##### 错误一http: server gave HTTP response to HTTPS client > ``` > root@k8s-master01:/home/master1/my_python_project# docker push 192.168.231.140:5000/my-app Using default tag: latest The push refers to repository [192.168.231.140:5000/my-app] Get "https://192.168.231.140:5000/v2/": http: server gave HTTP response to HTTPS client > ``` 这个错误信息表明Docker客户端在尝试通过HTTPS协议连接到你的私有仓库，但是服务器返回了一个HTTP响应。这通常意味着你的私有仓库没有正确配置为使用HTTPS，或者Docker客户端没有正确配置以信任仓库的SSL证书。 你可以通过修改Docker的配置文件来允许Docker客户端使用HTTP连接到你的私有仓库。以下是如何修改Docker配置文件的步骤： 1，打开Docker的配置文件，通常位于`/etc/docker/daemon.json`。如果文件不存在，你需要创建它。 > > ``` > sudo vim /etc/docker/daemon.json > ``` ,2，在文件中添加`insecure-registries`字段，并设置为你的私有仓库的地址。例如： JSON > ``` > { >  "insecure-registries" : ["192.168.231.140:5000"], > } > ``` 3，保存并关闭文件，然后重启Docker服务以使新的配置生效。 > > ``` > sudo systemctl daemon-reload > sudo systemctl restart docker > ``` ##### 错误二no basic auth credentials 根据Sealos的官方文档，Sealos私有仓库的默认用户名和密码是`admin:passw0rd`。你可以使用以下命令来登录到你的私有仓库： > > ``` > docker login -u admin -p passw0rd 192.168.231.140:5000 > ``` 或者使用Sealos的`login`命令： > > ``` > sealos login -u admin -p passw0rd 192.168.231.140:5000 > ``` #### sudo apt install docker-ce docker-ce-cli containerd.io：Waiting for cache lock: Could not get lock /var/lib/dpkg/lock-frontend. It is held by process 24775 (unattended-upgr) 这个错误是因为另一个进程（在这个例子中，进程号是24775）正在使用`dpkg`系统，这阻止了你运行`apt`命令。这通常发生在系统正在进行自动更新（如`unattended-upgrades`）时。 你可以使用以下命令来查看哪个进程正在使用`dpkg`系统： > > ``` > ps -aux | grep 24775 > ``` 如果你确定这个进程已经不再需要（例如，如果它是一个已经停止的自动更新进程），你可以使用`kill`命令来停止它： > > ``` > sudo kill -9 24775 > ``` 然后，你应该能够运行你的`apt`命令了。但是，请注意，强制停止一个正在运行的`dpkg`进程可能会导致系统包管理器处于不一致的状态，所以只有在你确定这个进程已经不再需要时，才应该这么做。