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    <none>          18h   v1.25.6
k8s-worker02   Ready    <none>          18h   v1.25.6
k8s-worker03   Ready    <none>          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    <none>          18h   v1.25.6
k8s-worker02   Ready    <none>          18h   v1.25.6
k8s-worker03   Ready    <none>          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博客

查看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：这是端口转发的设置，格式为 <本地端口>:<Pod 端口>。这意味着本地的 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

 

兼容性矩阵

指标服务器	指标 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

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 为内核的云操作系统

 

 

 

 

 

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 为内核的云操作系统

 

docker参考资料：

几张图帮你理解 docker 基本原理及快速入门 - 一天不进步，就是退步 - 博客园

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进程可能会导致系统包管理器处于不一致的状态，所以只有在你确定这个进程已经不再需要时，才应该这么做。