Version: Nächste

Einen neuen Chaos-Experimenttyp hinzufügen

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Dieses Dokument beschreibt, wie Sie einen neuen Chaos-Experimenttyp hinzufügen.

Im Folgenden wird das Beispiel HelloWorldChaos erläutert, ein neuer Chaos-Experimenttyp, der Hello world! ins Log schreibt. Die Schritte umfassen:

Schritt 1: Schema von HelloWorldChaos definieren
Schritt 2: CRD registrieren
Schritt 3: Event-Handler für helloworldchaos-Objekte registrieren
Schritt 4: Docker-Images erstellen
Schritt 5: HelloWorldChaos ausführen

Schritt 1: Schema von HelloWorldChaos definieren

Fügen Sie im API-Verzeichnis api/v1alpha1 die Datei helloworldchaos_types.go mit folgendem Inhalt hinzu:

package v1alpha1

import (
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// +kubebuilder:object:root=true
// +chaos-mesh:experiment
// +chaos-mesh:oneshot=true

// HelloWorldChaos is the Schema for the helloworldchaos API
type HelloWorldChaos struct {
        metav1.TypeMeta   `json:",inline"`
        metav1.ObjectMeta `json:"metadata,omitempty"`

        Spec   HelloWorldChaosSpec   `json:"spec"`
        Status HelloWorldChaosStatus `json:"status,omitempty"`
}

// HelloWorldChaosSpec defines the desired state of HelloWorldChaos
type HelloWorldChaosSpec struct {
        // ContainerSelector specifies the target for injection
        ContainerSelector `json:",inline"`

        // Duration represents the duration of the chaos
        // +optional
        Duration *string `json:"duration,omitempty"`

        // RemoteCluster represents the remote cluster where the chaos will be deployed
        // +optional
        RemoteCluster string `json:"remoteCluster,omitempty"`
}

// HelloWorldChaosStatus defines the observed state of HelloWorldChaos
type HelloWorldChaosStatus struct {
        ChaosStatus `json:",inline"`
}

// GetSelectorSpecs is a getter for selectors
func (obj *HelloWorldChaos) GetSelectorSpecs() map[string]interface{} {
        return map[string]interface{}{
                ".": &obj.Spec.ContainerSelector,
        }
}

Diese Datei definiert den Schematyp von HelloWorldChaos, der in einer YAML-Datei beschrieben werden kann:

apiVersion: chaos-mesh.org/v1alpha1
kind: HelloWorldChaos
metadata:
  name: <resource name>
  namespace: <namespace>
spec:
  duration: <duration>
#...

Schritt 2: CRD registrieren

Sie müssen die CRD (Custom Resource Definition) von HelloWorldChaos registrieren, um damit über die Kubernetes-API zu interagieren.

Um die CRD in manifests/crd.yaml zu integrieren, ergänzen Sie config/crd/kustomization.yaml um die im vorherigen Schritt generierte Datei config/crd/bases/chaos-mesh.org_helloworldchaos.yaml:

resources:
  - bases/chaos-mesh.org_podchaos.yaml
  - bases/chaos-mesh.org_networkchaos.yaml
  - bases/chaos-mesh.org_iochaos.yaml
  - bases/chaos-mesh.org_helloworldchaos.yaml # This is the new line

Führen Sie make generate im Chaos-Mesh-Stammverzeichnis aus. Dadurch wird ein Boilerplate für HelloWorldChaos generiert, das Chaos Mesh kompilieren kann:
```
make generate
```
Anschließend sehen Sie die Definition von HelloWorldChaos in manifests/crd.yaml.

Schritt 3: Event-Handler für helloworldchaos-Objekte registrieren

Erstellen Sie eine neue Datei controllers/chaosimpl/helloworldchaos/types.go mit folgendem Inhalt:

package helloworldchaos

import (
        "context"

        "github.com/go-logr/logr"
        "go.uber.org/fx"
        "sigs.k8s.io/controller-runtime/pkg/client"

        "github.com/chaos-mesh/chaos-mesh/api/v1alpha1"
        impltypes "github.com/chaos-mesh/chaos-mesh/controllers/chaosimpl/types"
        "github.com/chaos-mesh/chaos-mesh/controllers/chaosimpl/utils"
)

var _ impltypes.ChaosImpl = (*Impl)(nil)

type Impl struct {
        client.Client
        Log logr.Logger

        decoder *utils.ContainerRecordDecoder
}

// This corresponds to the Apply phase of HelloWorldChaos. The execution of HelloWorldChaos will be triggered.
func (impl *Impl) Apply(ctx context.Context, index int, records []*v1alpha1.Record, obj v1alpha1.InnerObject) (v1alpha1.Phase, error) {
        impl.Log.Info("Hello world!")
        return v1alpha1.Injected, nil
}

// This corresponds to the Recover phase of HelloWorldChaos. The reconciler will be triggered to recover the chaos action.
func (impl *Impl) Recover(ctx context.Context, index int, records []*v1alpha1.Record, obj v1alpha1.InnerObject) (v1alpha1.Phase, error) {
        impl.Log.Info("Goodbye world!")
        return v1alpha1.NotInjected, nil
}

// NewImpl returns a new HelloWorldChaos implementation instance.
func NewImpl(c client.Client, log logr.Logger, decoder *utils.ContainerRecordDecoder) *impltypes.ChaosImplPair {
        return &impltypes.ChaosImplPair{
                Name:   "helloworldchaos",
                Object: &v1alpha1.HelloWorldChaos{},
                Impl: &Impl{
                        Client:  c,
                        Log:     log.WithName("helloworldchaos"),
                        decoder: decoder,
                },
                ObjectList: &v1alpha1.HelloWorldChaosList{},
     }
}

var Module = fx.Provide(
         fx.Annotated{
                 Group:  "impl",
                 Target: NewImpl,
         },
)

Chaos Mesh verwendet die fx-Bibliothek für Dependency Injection. Um HelloWorldChaos im Controller Manager zu registrieren, fügen Sie eine Zeile in controllers/chaosimpl/fx.go ein:

var AllImpl = fx.Options(
        gcpchaos.Module,
        stresschaos.Module,
        jvmchaos.Module,
        timechaos.Module,
        helloworldchaos.Module // Add a new line. Make sure you have imported helloworldchaos first.
        //...
)

Fügen Sie dann in controllers/types/types.go den folgenden Inhalt in ChaosObjects ein:

var ChaosObjects = fx.Supply(
       //...
       fx.Annotated{
               Group: "objs",
               Target: Object{
                       Name:   "helloworldchaos",
                       Object: &v1alpha1.HelloWorldChaos{},
               },
       },
)

Schritt 4: Docker-Images erstellen

Erstellen Sie die Produktions-Images:
```
make image
```

Wenn Sie den Kubernetes-Cluster mit minikube bereitstellen, müssen Sie die Images in den Cluster laden:

minikube image load ghcr.io/chaos-mesh/chaos-dashboard:latest
minikube image load ghcr.io/chaos-mesh/chaos-mesh:latest
minikube image load ghcr.io/chaos-mesh/chaos-daemon:latest

Schritt 5: HelloWorldChaos ausführen

In diesem Schritt müssen Sie Chaos Mesh mit Ihren letzten Änderungen bereitstellen, um HelloWorldChaos zu testen.

Registrieren Sie die CRD in Ihrem Cluster:
```
kubectl create -f manifests/crd.yaml
```
Sie sehen in der Ausgabe, dass HelloWorldChaos erstellt wurde:
```
customresourcedefinition.apiextensions.k8s.io/helloworldchaos.chaos-mesh.org created
```
Jetzt können Sie die CRD von HelloWorldChaos mit folgendem Befehl abrufen:
```
kubectl get crd helloworldchaos.chaos-mesh.org
```

Stellen Sie Chaos Mesh bereit:

helm install chaos-mesh helm/chaos-mesh -n=chaos-mesh --set controllerManager.leaderElection.enabled=false,dashboard.securityMode=false

Um den erfolgreichen Bereitstellungsstatus zu prüfen, können Sie alle Pods im chaos-mesh-Namespace überprüfen:

kubectl get pods --namespace chaos-mesh -l app.kubernetes.io/instance=chaos-mesh

Stellen Sie ein Deployment für Tests bereit. Wir verwenden hierzu einen Beispiel-Echo-Server aus der minikube-Dokumentation:

kubectl create deployment hello-minikube --image=kicbase/echo-server:1.0

Warten Sie, bis der Pod den Status "Running" hat:

kubectl get pods

Beispielausgabe:

NAME                              READY   STATUS    RESTARTS   AGE
hello-minikube-77b6f68484-dg4sw   1/1     Running   0          2m

Erstellen Sie eine hello.yaml-Datei mit folgendem Inhalt:

apiVersion: chaos-mesh.org/v1alpha1
kind: HelloWorldChaos
metadata:
  name: hello-world
  namespace: chaos-mesh
spec:
  selector:
    labelSelectors:
      app: hello-minikube
  mode: one
  duration: 1h

Führen Sie den Befehl aus:

kubectl apply -f hello.yaml
# helloworldchaos.chaos-mesh.org/hello-world created

Jetzt können Sie prüfen, ob chaos-controller-manager Hello world! in seinen Logs ausgibt:

kubectl logs -n chaos-mesh chaos-controller-manager-xxx

Beispielausgabe:

2023-07-16T06:19:40.068Z INFO records records/controller.go:149 apply chaos {"id": "default/hello-minikube-77b6f68484-dg4sw/echo-server"}
2023-07-16T06:19:40.068Z INFO helloworldchaos helloworldchaos/types.go:26 Hello world!

Nächste Schritte

Bei Problemen während der Umsetzung können Sie ein Issue im Chaos Mesh Repository erstellen.

Im nächsten Abschnitt erfahren Sie mehr über die Erweiterung des Verhaltens von HelloWorldChaos.

Schritt 1: Schema von HelloWorldChaos definieren​

Schritt 2: CRD registrieren​

Schritt 3: Event-Handler für helloworldchaos-Objekte registrieren​

Schritt 4: Docker-Images erstellen​

Schritt 5: HelloWorldChaos ausführen​

Nächste Schritte​