データベースとしての Kubernetes? CRD について知っておくべきこと

急速に発展しているクラウドネイティブ テクノロジーの分野において、Kubernetes はコンテナ化されたアプリケーション オーケストレーションのための強力なツールとなっています。しかし、開発者やIT専門家の間では、「Kubernetesはデータベースなのか？」という意見があります。よくある質問です。この投稿では、この質問を検討し、カスタム リソース定義 (CRD) について徹底的に説明し、Kubernetes エコシステムでの CRD の使用法に焦点を当てます。私たちはこれらのアイデアを明確にし、ステートフル アプリケーション管理における Kubernetes の適応性と能力を、徹底的なコード例と実際のアプリケーションを使って説明したいと考えています。

Kubernetes の概要

Kubernetes (K8s と略されることも多い) は、アプリケーション コンテナのデプロイ、スケーリング、操作を自動化するように設計されたオープンソース プラットフォームです。最初に Google によって開発された Kubernetes は、活気に満ちたコミュニティと幅広いツールや拡張機能によってサポートされ、コンテナ オーケストレーションの事実上の標準になりました。

Kubernetes の中心的な概念

CRD の詳細とデータベースとしての Kubernetes の問題に入る前に、いくつかの核となる概念を理解することが重要です。

ポッド: Kubernetes でデプロイ可能な最小単位であり、クラスター内で実行中のプロセスの単一インスタンスを表します。

ノード: Kubernetes のワーカー マシン。仮想または物理のいずれかです。

クラスター: Kubernetes マスターによって制御されるノードのセット。

サービス: ポッドの論理セットとそれらにアクセスするためのポリシーを定義する抽象化。

データベースとしての Kubernetes: 神話か現実か?

Kubernetes 自体はデータベースではありません。データベースを含むコンテナ化されたアプリケーションを管理できるオーケストレーション プラットフォームです。ただし、Kubernetes を使用してデータベース アプリケーションを効果的にデプロイおよび管理できるため、混乱が生じることがよくあります。

カスタム リソース定義 (CRD) について

カスタム リソース定義 (CRD) は、Kubernetes API を拡張して、ユーザーが独自のアプリケーション固有のカスタム リソースを管理できるようにします。この機能により、Kubernetes は拡張性が高く、さまざまなユースケースに合わせてカスタマイズできるようになります。

CRD とは何ですか?

CRD を使用すると、ユーザーは組み込みの Kubernetes リソースのように動作するカスタム オブジェクトを定義できます。たとえば、Kubernetes にはポッド、サービス、デプロイメントなどの組み込みリソースがありますが、「MySQLCluster」や「PostgreSQLBackup」などのカスタム リソースを作成できます。

CRD の作成

CRD を作成するには、YAML ファイルで定義し、Kubernetes クラスターに適用する必要があります。基本的な例を次に示します:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myresources.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
  scope: Namespaced
  names:
    plural: myresources
    singular: myresource
    kind: MyResource
    shortNames:
      - mr

kubectl apply -f myresource-crd.yaml を使用してこの YAML ファイルを適用すると、クラスター内にカスタム リソース定義が作成されます。

カスタム リソースの管理

CRD が作成されたら、ネイティブ Kubernetes リソースと同様にカスタム リソースの管理を開始できます。カスタム リソース インスタンスの例を次に示します:

apiVersion: example.com/v1
kind: MyResource
metadata:
  name: myresource-sample
spec:
  foo: bar
  count: 10

このカスタム リソースは次のコマンドで作成できます:

kubectl apply -f myresource-instance.yaml

ステートフル アプリケーションでの CRD の使用

カスタム リソース定義は、データベースなどのステートフル アプリケーションの管理に特に役立ちます。これらを使用すると、データベース クラスター、バックアップ ポリシー、その他のカスタム動作の望ましい状態を定義できます。

例: CRD を使用した MySQL クラスターの管理

Kubernetes を使用して MySQL クラスターを管理する必要があるシナリオを考えてみましょう。 MySQL クラスター構成を表すカスタム リソースを定義できます。

apiVersion: example.com/v1
kind: MySQLCluster
metadata:
  name: my-mysql-cluster
spec:
  replicas: 3
  version: "5.7"
  storage:
    size: 100Gi
    class: standard

この CRD を使用すると、標準の Kubernetes コマンドを使用して MySQL クラスターを作成、更新、削除できるため、データベース管理がより簡単になり、インフラストラクチャの残りの部分と統合されます。

高度な CRD 機能

CRD は、その機能と Kubernetes エコシステムとの統合を強化するいくつかの高度な機能を提供します。

検証スキーマ

カスタム リソースの検証スキーマを定義して、有効な構成のみが受け入れられるようにすることができます。 MySQLCluster CRD に検証スキーマを追加する例を次に示します:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: mysqlclusters.example.com
spec:
  group: example.com
  versions:
    - name: v1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                replicas:
                  type: integer
                  minimum: 1
                version:
                  type: string
                storage:
                  type: object
                  properties:
                    size:
                      type: string
                    class:
                      type: string
  scope: Namespaced
  names:
    plural: mysqlclusters
    singular: mysqlcluster
    kind: MySQLCluster
    shortNames:
      - mc

カスタム コントローラー

カスタム リソースの管理を自動化するために、カスタム コントローラーを作成できます。これらのコントローラーはカスタム リソースへの変更を監視し、実際の状態と望ましい状態を一致させるためのアクションを実行します。

MySQLCluster リソースのコントローラーを作成する方法の概要を次に示します。

package main

import (
    "context"
    "log"

    mysqlv1 "example.com/mysql-operator/api/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/client-go/kubernetes/scheme"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/manager"
)

type MySQLClusterReconciler struct {
    client.Client
    Scheme *runtime.Scheme
}

func (r *MySQLClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var mysqlCluster mysqlv1.MySQLCluster
    if err := r.Get(ctx, req.NamespacedName, &mysqlCluster); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // Reconciliation logic goes here

    return ctrl.Result{}, nil
}

func main() {
    mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
        Scheme: scheme.Scheme,
    })
    if err != nil {
        log.Fatalf("unable to start manager: %v", err)
    }

    if err := (&MySQLClusterReconciler{
        Client: mgr.GetClient(),
        Scheme: mgr.GetScheme(),
    }).SetupWithManager(mgr); err != nil {
        log.Fatalf("unable to create controller: %v", err)
    }

    if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
        log.Fatalf("unable to run manager: %v", err)
    }
}

バージョン管理

CRD はバージョン管理をサポートしているため、カスタム リソースのさまざまなバージョンを管理し、それらの間でスムーズに移行できます。これは、下位互換性を維持し、時間の経過とともに API を進化させるために非常に重要です。

ケーススタディ: データベース用の Kubernetes オペレーター

Kubernetes Operators leverage CRDs and custom controllers to automate the management of complex stateful applications like databases. Let's explore a real-world example: the MySQL Operator.

The MySQL Operator

The MySQL Operator simplifies the deployment and management of MySQL clusters on Kubernetes. It uses CRDs to define the desired state of the MySQL cluster and custom controllers to handle tasks like provisioning, scaling, and backups.

Defining the MySQLCluster CRD

The MySQL Operator starts by defining a CRD for the MySQLCluster resource, as shown earlier. This CRD includes fields for specifying the number of replicas, MySQL version, storage requirements, and more.

Writing the MySQLCluster Controller

The controller for the MySQLCluster resource continuously watches for changes to MySQLCluster objects and reconciles the actual state with the desired state. For example, if the number of replicas is increased, the controller will create new MySQL instances and configure them to join the cluster.

Code Example: Scaling a MySQL Cluster

Here’s a simplified version of the controller logic for scaling a MySQL cluster:

func (r *MySQLClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var mysqlCluster mysqlv1.MySQLCluster
    if err := r.Get(ctx, req.NamespacedName, &mysqlCluster); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // Fetch the current number of MySQL pods
    var pods corev1.PodList
    if err := r.List(ctx, &pods, client.InNamespace(req.Namespace), client.MatchingLabels{
        "app":  "mysql",
        "role": "master",
    }); err != nil {
        return ctrl.Result{}, err
    }

    currentReplicas := len(pods.Items)
    desiredReplicas := mysqlCluster.Spec.Replicas

    if currentReplicas < desiredReplicas {
        // Scale up
        for i := currentReplicas; i < desiredReplicas; i++ {
            newPod := corev1.Pod{
                ObjectMeta: metav1.ObjectMeta{
                    Name:      fmt.Sprintf("mysql-%d", i),
                    Namespace: req.Namespace,
                    Labels: map[string

]string{
                        "app":  "mysql",
                        "role": "master",
                    },
                },
                Spec: corev1.PodSpec{
                    Containers: []corev1.Container{
                        {
                            Name:  "mysql",
                            Image: "mysql:5.7",
                            Ports: []corev1.ContainerPort{
                                {
                                    ContainerPort: 3306,
                                },
                            },
                        },
                    },
                },
            }
            if err := r.Create(ctx, &newPod); err != nil {
                return ctrl.Result{}, err
            }
        }
    } else if currentReplicas > desiredReplicas {
        // Scale down
        for i := desiredReplicas; i < currentReplicas; i++ {
            podName := fmt.Sprintf("mysql-%d", i)
            pod := &corev1.Pod{
                ObjectMeta: metav1.ObjectMeta{
                    Name:      podName,
                    Namespace: req.Namespace,
                },
            }
            if err := r.Delete(ctx, pod); err != nil {
                return ctrl.Result{}, err
            }
        }
    }

    return ctrl.Result{}, nil
}

Benefits of Using Kubernetes Operators

Kubernetes Operators, built on CRDs and custom controllers, provide several benefits for managing stateful applications:

Automation: Operators automate routine tasks such as scaling, backups, and failover, reducing the operational burden on administrators.

Consistency: By encapsulating best practices and operational knowledge, Operators ensure that applications are managed consistently and reliably.

Extensibility: Operators can be extended to support custom requirements and integrate with other tools and systems.

Conclusion

Although Kubernetes is not a database in and of itself, it offers a strong framework for installing and administering database applications. A strong addition to the Kubernetes API, bespoke Resource Definitions (CRDs) allow users to design and manage bespoke resources that are suited to their particular requirements.

You may build Kubernetes Operators that automate the administration of intricate stateful applications, such as databases, by utilizing CRDs and custom controllers. This method offers more flexibility and customization, improves consistency, and streamlines processes.

This article has covered the foundations of CRDs, shown comprehensive code examples, and shown how stateful applications may be efficiently managed with CRDs. To fully utilize Kubernetes, you must comprehend and make use of CRDs, regardless of whether you are implementing databases or other sophisticated services on this potent orchestration platform.

As Kubernetes develops further, its adaptability to a variety of use cases and needs is ensured by its expansion through CRDs and Operators. Keep investigating and experimenting with these functionalities as you progress with Kubernetes to open up new avenues for your infrastructure and apps.

以上がデータベースとしての Kubernetes? CRD について知っておくべきことの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。