建立公司_crm公司_seo数据分析哪些方面_西安seo优化顾问

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解决的问题

服务部署和扩展：Kubernetes可以自动部署、扩展和管理容器化的应用程序，使得服务部署和扩展变得更加简单和快速。

就像你有一个机器人厨师，你告诉他你需要多少个汉堡，他就会自动做出相应数量的汉堡。如果你需要更多的汉堡，他会自动做更多。
服务发现和负载均衡：Kubernetes可以自动发现和平衡负载，从而提高服务的可用性和稳定性。

如果你有很多机器人厨师，Kubernetes就像一个经理，它会确保每个厨师的工作量都差不多，没有人会被压垮。
自动回滚和恢复：Kubernetes可以在应用程序出现故障时自动回滚和恢复，从而提高服务的可靠性。

如果一个机器人厨师犯了错误（比如做出了一个不好吃的汉堡），Kubernetes会让他停下来，然后找另一个机器人厨师接替他的工作。
密钥和配置管理：Kubernetes可以管理和保护敏感数据，如密码、OAuth令牌和SSH密钥。

Kubernetes就像一个保险箱，它可以安全地存储和管理你的秘密配方和其他重要信息。
存储编排：Kubernetes允许你自动挂载你选择的存储系统，例如本地存储、公共云提供商等。

如果你的机器人厨师需要某种特殊的食材，Kubernetes会确保他们可以在需要的时候获取到。
批处理和CI/CD：Kubernetes可以管理批处理和CI/CD工作流，替代传统的主机依赖的工作流。

Kubernetes可以管理你的整个厨房工作流程，确保每个步骤都按照计划进行。
资源优化：Kubernetes可以根据资源需求和约束自动放置容器，从而提高资源利用率。

Kubernetes会确保每个机器人厨师都有足够的资源（比如时间和空间）来完成他们的工作，但又不会浪费任何资源。
自我修复：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组件和工具：

Metrics Server：Metrics Server是一个集群范围的资源指标的聚合器，它被Metrics API使用。这是查看资源使用情况的基础设施。
Heapster（已被弃用）：Heapster是一个性能监控和事件数据聚合系统，它可以收集和解释各种事件和指标。
Prometheus：Prometheus是一个开源的监控和警报工具包，它可以收集和存储可靠的时间序列数据。
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登录。以下是具体的步骤：

打开SSH的配置文件：
```
sudo vim /etc/ssh/sshd_config
```
在打开的文件中，找到PermitRootLogin prohibit-password这一行。
将这一行改为PermitRootLogin yes。
保存并关闭文件。
重启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 集群中的重要组件，它们各自有不同的作用：

labring/helm:v3.12.0：Helm 是 Kubernetes 的一个包管理工具，类似于 Linux 下的 apt 或 yum。它可以帮助用户通过定义配置文件的方式来部署和管理 Kubernetes 应用，极大地简化了应用在 Kubernetes 上的部署和管理流程。
labring/calico:v3.24.1：Calico 是一个网络策略引擎，它提供了网络策略和网络路由的功能，可以用于 Kubernetes 集群的网络策略管理和 Pod 网络的构建。
labring/cert-manager:v1.8.0：Cert-Manager 是一个用于 Kubernetes 集群中自动化管理 TLS 证书的开源工具。它使用了 Kubernetes 的自定义资源定义（CRD）机制，让证书的创建、更新和删除变得非常容易。
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.6docker.io/labring/helm:v3.12.0docker.io/labring/calico:v3.24.1docker.io/labring/cert-manager:v1.8.0docker.io/labring/openebs:v3.4.0docker.io/labring/kubernetes-reflector:v7.0.151docker.io/labring/ingress-nginx:v1.5.1docker.io/labring/zot:v1.4.3docker.io/labring/kubeblocks:v0.5.3docker.io/labring/sealos-cloud:latest
)

for image in "${images[@]}"; dosealos 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-beta5ghcr.io/labring/sealos-cloud-template-frontend:latestghcr.io/labring/sealos-cloud-terminal-frontend:latestghcr.io/labring/sealos-cloud-applaunchpad-frontend:latestghcr.io/labring/sealos-cloud-desktop-frontend:latestghcr.io/labring/sealos-cloud-dbprovider-frontend:latestghcr.io/labring/sealos-cloud-cronjob-frontend:latestghcr.io/labring/sealos-cloud-costcenter-frontend:latestghcr.io/labring/sealos-cloud-license-frontend:latestghcr.io/labring/sealos-cloud-terminal-controller:latestghcr.io/labring/sealos-cloud-user-controller:latestghcr.io/labring/sealos-cloud-resources-controller:latestghcr.io/labring/sealos-cloud-job-init-controller:latestghcr.io/labring/sealos-cloud-license-controller:latestghcr.io/labring/sealos-cloud-job-heartbeat-controller:latestghcr.io/labring/sealos-cloud-app-controller:latestghcr.io/labring/sealos-cloud-account-controller:latestregistry.cn-shanghai.aliyuncs.com/labring/kubernetes:v1.27.11ghcr.io/labring/sealos-cloud-account-service:latestghcr.io/labring/sealos-cloud-database-service:latestghcr.io/labring/sealos-cloud-launchpad-service:latestregistry.cn-shanghai.aliyuncs.com/labring/kubeblocks-apecloud-mysql:v0.8.2registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-postgresql:v0.8.2registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-mongodb:v0.8.2registry.cn-shanghai.aliyuncs.com/labring/kubeblocks:v0.8.2registry.cn-shanghai.aliyuncs.com/labring/kubeblocks-redis:v0.8.2registry.cn-shanghai.aliyuncs.com/labring/cockroach:latestregistry.cn-shanghai.aliyuncs.com/labring/cilium:v1.14.8registry.cn-shanghai.aliyuncs.com/labring/cert-manager:v1.14.4registry.cn-shanghai.aliyuncs.com/labring/openebs:v3.10.0registry.cn-shanghai.aliyuncs.com/labring/helm:v3.14.1registry.cn-shanghai.aliyuncs.com/labring/victoria-metrics-k8s-stack:v1.96.0registry.cn-shanghai.aliyuncs.com/labring/ingress-nginx:v1.9.4registry.cn-shanghai.aliyuncs.com/labring/metrics-server:v0.6.4
)

for image in "${images[@]}"; dofilename=$(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; dosealos 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 集群中的资源信息。下面是对这些命令的解析和备注：

kubectl get pods: 这个命令用于获取 Kubernetes 集群中的所有 Pod 的信息。Pod 是 Kubernetes 中的最小部署单元，每个 Pod 可以包含一个或多个容器。这个命令会列出所有的 Pod，包括它们的名称、状态、重启次数和运行时间等信息。
kubectl get ns: 这个命令用于获取 Kubernetes 集群中的所有命名空间（Namespace）的信息。命名空间是 Kubernetes 中用于将资源进行逻辑隔离的一种方式。这个命令会列出所有的命名空间，包括它们的名称和状态等信息。
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 的 Podreplicas: 1  # 副本数，表示这个 Deployment 管理的 Pod 的数量template:  # Pod 模板，用于创建新的 Podmetadata:labels:app: nginx  # 标签，会被添加到所有由这个 Deployment 创建的 Pod 上spec:containers:  # 容器列表，每个 Pod 可以包含一个或多个容器- name: nginx  # 容器的名称image: 192.168.231.140:5000/my_nginx  # 容器的镜像ports:  # 容器的端口列表- containerPort: 80  # 容器的端口号

这个 YAML 文件包含二部分：

创建一个名为 my-namespace 的命名空间。
在 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

kubectl get pod -o wide: 这个命令用于获取 Kubernetes 集群中的所有 Pod 的详细信息。-o wide 参数表示输出详细的信息，包括每个 Pod 的 IP 地址、所在的节点等。
kubectl describe svc nginx: 这个命令用于获取 Kubernetes 集群中名为 nginx 的 Service 的详细描述信息。这个命令的输出包括 Service 的类型、端口映射、选择器、事件等信息。
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: nulllabels:app: nginxname: nginx
spec:ports:- port: 8080protocol: TCPtargetPort: 8080selector:app: nginx
status:loadBalancer: {}#nginx_service.yaml文件修改后
apiVersion: v1
kind: Service
metadata:labels:app: nginxname: nginx
spec:ports:- port: 8080protocol: TCPtargetPort: 80selector:app: nginx

在这个 Kubernetes Service 配置中：

port: 8080 是向外暴露的端口（也被称为服务端口）。这是其他服务或客户端在集群内部访问这个 Service 时使用的端口。
targetPort: 8080 是容器的 Pod 端口。这是 Service 将流量路由到的 Pod 中的容器端口。

apply运行

kubectl apply -f nginx_service.yaml
kubectl get svc

集群内部pod应用访问集群外部服务

详细步骤

部署外部集群
创建endpoint
创建service
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-mysqlnamespace: 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-mysqlnamespace: external-ns
spec:type: ClusterIPports:- port: 3306targetPort: 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: bookinfonamespace: external-ns
spec:replicas: 1selector:matchLabels:app: flask-bookinfotemplate:metadata:labels:app: flask-bookinfospec:containers:- name: flask-bookinfoimage: kubernetes-register.sswang.com/sswang/flask_bookinfo:2.3.2imagePullPolicy: Alwaysports:- containerPort: 5000env:- name: DB_HOSTvalue: "ex-mysql"  # 数据库主机名- name: DB_USERvalue: "root"  # 数据库用户名- name: DB_PASSWORDvalue: "123456"  # 数据库密码- name: DB_DATABASEvalue: "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的主要作用有：

环境一致性：无论开发、测试还是生产环境，Docker都能保证环境的一致性，避免了“在我机器上可以运行”的问题。
快速部署：Docker可以快速地启动容器（通常在几秒钟内），使得应用的部署、扩展和迁移变得更加高效。
持续交付和部署：使用Docker，你可以构建一个容器来运行你的应用，然后把这个容器发布出去。其他人可以直接使用你的容器来运行应用，无需关心环境问题。
隔离性：每个Docker容器都运行在自己的环境中，互不干扰。
微服务架构：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 的步骤：

更新包管理器：
```
sudo apt update
```

安装 Docker 的依赖包：

sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release

添加阿里云 Docker 镜像源 GPG 密钥：

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

添加阿里云 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 官方文档提供的相应命令。

更新 apt 缓存：
```
sudo apt update
```

安装 Docker：

sudo apt install docker-ce docker-ce-cli containerd.io

启动 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

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