Kubernetes sebagai Pangkalan Data? Perkara yang Anda Perlu Tahu Mengenai CRD

Dalam bidang teknologi asli awan yang pesat membangun, Kubernetes telah menjadi alat yang mujarab untuk orkestrasi aplikasi kontena. Tetapi di kalangan pemaju dan pakar IT, "Adakah Kubernetes pangkalan data?" adalah soalan yang sering ditanya. Siaran ini meneroka soalan ini dan menawarkan penerangan terperinci tentang Definisi Sumber Tersuai (CRD), yang menyerlahkan penggunaannya dalam ekosistem Kubernetes. Kami berharap dapat menjelaskan idea ini dan menggambarkan kebolehsuaian dan kuasa Kubernetes dalam pengurusan aplikasi stateful dengan contoh kod yang teliti dan aplikasi dunia nyata.

Pengenalan kepada Kubernetes

Kubernetes, sering disingkatkan sebagai K8, ialah platform sumber terbuka yang direka untuk mengautomasikan penggunaan, penskalaan dan pengendalian bekas aplikasi. Pada mulanya dibangunkan oleh Google, Kubernetes telah menjadi standard de facto untuk orkestrasi kontena, disokong oleh komuniti yang bertenaga dan pelbagai alat serta sambungan.

Konsep Teras Kubernetes

Sebelum menyelami spesifik CRD dan persoalan Kubernetes sebagai pangkalan data, adalah penting untuk memahami beberapa konsep teras:

Pod: Unit terkecil yang boleh digunakan dalam Kubernetes, mewakili satu contoh proses yang sedang berjalan dalam gugusan.

Nod: Mesin pekerja dalam Kubernetes, yang boleh sama ada maya atau fizikal.

Kluster: Satu set nod yang dikawal oleh induk Kubernetes.

Perkhidmatan: Abstraksi yang mentakrifkan set logik pod dan dasar untuk mengaksesnya.

Kubernetes sebagai Pangkalan Data: Mitos atau Realiti?

Kubernetes sendiri bukan pangkalan data. Ia adalah platform orkestrasi yang boleh mengurus aplikasi kontena, termasuk pangkalan data. Walau bagaimanapun, kekeliruan sering timbul kerana Kubernetes boleh digunakan untuk mengatur dan mengurus aplikasi pangkalan data dengan berkesan.

Memahami Definisi Sumber Tersuai (CRD)

Definisi Sumber Tersuai (CRD) melanjutkan API Kubernetes untuk membolehkan pengguna mengurus sumber tersuai khusus aplikasi mereka sendiri. Keupayaan ini menjadikan Kubernetes sangat boleh diperluaskan dan boleh disesuaikan untuk memuatkan pelbagai kes penggunaan.

Apakah CRD?

CRD membolehkan pengguna mentakrifkan objek tersuai yang berkelakuan seperti sumber Kubernetes terbina dalam. Sebagai contoh, walaupun Kubernetes mempunyai sumber terbina dalam seperti Pod, Perkhidmatan dan Penerapan, anda boleh mencipta sumber tersuai seperti "MySQLCluster" atau "PostgreSQLBackup."

Mencipta CRD

Untuk mencipta CRD, anda perlu mentakrifkannya dalam fail YAML dan menggunakannya pada kelompok Kubernetes anda. Berikut ialah contoh asas:

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

Menggunakan fail YAML ini dengan kubectl apply -f myresource-crd.yaml akan mencipta definisi sumber tersuai dalam kelompok anda.

Mengurus Sumber Tersuai

Setelah CRD dibuat, anda boleh mula mengurus sumber tersuai seperti yang anda lakukan dengan sumber Kubernetes asli. Berikut ialah contoh contoh sumber tersuai:

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

Anda boleh mencipta sumber tersuai ini dengan:

kubectl apply -f myresource-instance.yaml

Menggunakan CRD untuk Aplikasi Stateful

Definisi Sumber Tersuai amat berguna untuk mengurus aplikasi stateful, termasuk pangkalan data. Ia membenarkan anda mentakrifkan keadaan kluster pangkalan data yang dikehendaki, dasar sandaran dan gelagat tersuai lain.

Contoh: Mengurus Kluster MySQL dengan CRD

Pertimbangkan senario di mana anda perlu mengurus gugusan MySQL dengan Kubernetes. Anda boleh menentukan sumber tersuai untuk mewakili konfigurasi kluster MySQL:

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

Dengan CRD ini, anda boleh membuat, mengemas kini dan memadamkan kluster MySQL menggunakan perintah Kubernetes standard, menjadikan pengurusan pangkalan data lebih mudah dan bersepadu dengan infrastruktur anda yang lain.

Ciri CRD Terperinci

CRD menawarkan beberapa ciri lanjutan yang meningkatkan kefungsian dan integrasinya dengan ekosistem Kubernetes.

Skema Pengesahan

Anda boleh menentukan skema pengesahan untuk sumber tersuai untuk memastikan bahawa hanya konfigurasi yang sah diterima. Berikut ialah contoh menambah skema pengesahan pada 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

Pengawal Tersuai

Untuk mengautomasikan pengurusan sumber tersuai, anda boleh menulis pengawal tersuai. Pengawal ini memantau perubahan pada sumber tersuai dan mengambil tindakan untuk menyelaraskan keadaan sebenar dengan keadaan yang dikehendaki.

Berikut ialah garis besar cara anda boleh menulis pengawal untuk sumber 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)
    }
}

Versi

CRD menyokong versi, membolehkan anda mengurus versi berbeza sumber tersuai anda dan berhijrah antara mereka dengan lancar. Ini penting untuk mengekalkan keserasian ke belakang dan mengembangkan API anda dari semasa ke semasa.

Kajian Kes: Operator Kubernetes untuk Pangkalan Data

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.

Atas ialah kandungan terperinci Kubernetes sebagai Pangkalan Data? Perkara yang Anda Perlu Tahu Mengenai CRD. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!