Aller au contenu principal
Version : 2.6.7

Étendre l'interface Chaos Daemon

Traduction Bêta Non Officielle

Cette page a été traduite par PageTurner AI (bêta). Non approuvée officiellement par le projet. Vous avez trouvé une erreur ? Signaler un problème →

Dans Ajouter un nouveau type d'expérience de chaos, vous avez ajouté HelloWorldChaos qui affiche Hello world! dans les logs de Chaos Controller Manager.

Pour permettre à HelloWorldChaos d'injecter des perturbations dans le Pod cible, vous devez étendre l'interface Chaos Daemon.

astuce

Il est recommandé de lire l'architecture de Chaos Mesh avant de poursuivre.

Ce document aborde :

Sélecteur​

Dans api/v1alpha1/helloworldchaos_type.go, vous avez défini HelloWorldSpec qui inclut ContainerSelector :

// 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"`
}

//...

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

Dans Chaos Mesh, le sélecteur définit la portée d'une expérience de chaos : namespace cible, annotations, labels, etc.

Les sélecteurs peuvent aussi prendre des valeurs plus spécifiques (par ex. AWSSelector dans AWSChaos). Normalement, une expérience de chaos ne nécessite qu'un seul sélecteur, sauf exception comme NetworkChaos qui nécessite parfois deux sélecteurs pour partitionner le réseau.

Consultez Définir la portée des expériences de chaos pour plus d'informations sur les sélecteurs.

Implémenter l'interface gRPC​

Pour que Chaos Daemon accepte les requêtes de Chaos Controller Manager, vous devez implémenter une nouvelle interface gRPC.

  1. Ajoutez le RPC dans pkg/chaosdaemon/pb/chaosdaemon.proto :

    service ChaosDaemon {
       ...

       rpc ExecHelloWorldChaos(ExecHelloWorldRequest) returns (google.protobuf.Empty) {}
    }

    message ExecHelloWorldRequest {
       string container_id = 1;
    }

    Mettez ensuite à jour le fichier chaosdaemon.pb.go associé avec la commande :

    make proto

  2. Implémentez les services gRPC dans Chaos Daemon.

    Dans le répertoire pkg/chaosdaemon, créez un fichier helloworld_server.go avec ce contenu :

    package chaosdaemon

    import (
            "context"

            "github.com/golang/protobuf/ptypes/empty"

            "github.com/chaos-mesh/chaos-mesh/pkg/bpm"
            "github.com/chaos-mesh/chaos-mesh/pkg/chaosdaemon/pb"
    )

    func (s *DaemonServer) ExecHelloWorldChaos(ctx context.Context, req *pb.ExecHelloWorldRequest) (*empty.Empty, error) {
            log := s.getLoggerFromContext(ctx)
            log.Info("ExecHelloWorldChaos", "request", req)

            pid, err := s.crClient.GetPidFromContainerID(ctx, req.ContainerId)
            if err != nil {
                    return nil, err
            }

            cmd := bpm.DefaultProcessBuilder("sh", "-c", "ps aux").
                    SetContext(ctx).
                    SetNS(pid, bpm.MountNS).
                    Build(ctx)
            out, err := cmd.Output()
            if err != nil {
                    return nil, err
            }
            if len(out) != 0 {
                    log.Info("cmd output", "output", string(out))
            }

            return &empty.Empty{}, nil
    }

    Après réception de la requête ExecHelloWorldChaos, chaos-daemon affiche la liste des processus du conteneur actuel.

  3. Envoyer une requête gRPC lors de l'application de l'expérience de chaos.

    Chaque expérience de chaos suit un cycle de vie : apply puis recover. Cependant, certaines expériences ne peuvent pas être récupérées par défaut (par exemple PodKill dans PodChaos et HelloWorldChaos). Ces expériences sont appelées OneShot. Vous pouvez voir +chaos-mesh:oneshot=true que nous avons défini dans le schéma HelloWorldChaos.

    Le chaos controller manager doit envoyer une requête au chaos daemon pendant la phase apply de HelloWorldChaos. Pour cela, mettez à jour controllers/chaosimpl/helloworldchaos/types.go :

    func (impl *Impl) Apply(ctx context.Context, index int, records []*v1alpha1.Record, obj v1alpha1.InnerObject) (v1alpha1.Phase, error) {
            impl.Log.Info("Apply helloworld chaos")

            decodedContainer, err := impl.decoder.DecodeContainerRecord(ctx, records[index], obj)
            if err != nil {
                    return v1alpha1.NotInjected, err
            }

            pbClient := decodedContainer.PbClient
            containerId := decodedContainer.ContainerId

            _, err = pbClient.ExecHelloWorldChaos(ctx, &pb.ExecHelloWorldRequest{
                    ContainerId: containerId,
            })
            if err != nil {
                    return v1alpha1.NotInjected, err
            }

            return v1alpha1.Injected, nil
    }

    func (impl *Impl) Recover(ctx context.Context, index int, records []*v1alpha1.Record, obj v1alpha1.InnerObject) (v1alpha1.Phase, error) {
            impl.Log.Info("Recover helloworld chaos")
            return v1alpha1.NotInjected, nil
    }
    info

    Il n'est pas nécessaire de récupérer HelloWorldChaos car HelloWorldChaos est une expérience OneShot. Pour le type d'expérience de chaos que vous développez, implémentez la logique de récupération selon vos besoins.

Vérifier la sortie de HelloWorldChaos​

Vous pouvez maintenant vérifier la sortie de HelloWorldChaos :

  1. Construisez les images Docker comme décrit dans Ajouter un nouveau type d'expérience de chaos, puis chargez-les dans votre cluster.

    note

    Si vous utilisez minikube, certaines versions ne permettent pas d'écraser les images existantes avec le même tag. Vous devrez peut-être supprimer les images existantes avant de charger les nouvelles.

  2. Update Chaos Mesh:

  3. Déployez un Pod de test :

    kubectl apply -f https://raw.githubusercontent.com/chaos-mesh/apps/master/ping/busybox-statefulset.yaml

  4. Créez un fichier hello-busybox.yaml avec le contenu suivant :

    apiVersion: chaos-mesh.org/v1alpha1
    kind: HelloWorldChaos
    metadata:
      name: hello-busybox
      namespace: chaos-mesh
    spec:
      selector:
        namespaces:
          - busybox
      mode: all
      duration: 1h

  5. Exécutez :

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

    • Vérifiez maintenant si chaos-controller-manager contient Apply helloworld chaos dans ses journaux :

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

      Exemple de sortie :

      2023-07-16T08:20:46.823Z INFO records records/controller.go:149 apply chaos {"id": "busybox/busybox-0/busybox"}
      2023-07-16T08:20:46.823Z INFO helloworldchaos helloworldchaos/types.go:27 Apply helloworld chaos

    • Vérifiez les journaux de Chaos Daemon :

      kubectl logs -n chaos-mesh chaos-daemon-xxx

      Exemple de sortie :

      2023-07-16T08:20:46.833Z INFO chaos-daemon.daemon-server chaosdaemon/server.go:187 ExecHelloWorldChaos {"namespacedName": "chaos-mesh/hello-busybox", "request": "container_id:\"docker://5e01e76efdec6aa0934afc15bb80e121d58b43c529a6696a01a242f7ac68f201\""}
      2023-07-16T08:20:46.834Z INFO chaos-daemon.daemon-server.background-process-manager.process-builder pb/chaosdaemon.pb.go:4568 build command {"namespacedName": "chaos-mesh/hello-busybox", "command": "/usr/local/bin/nsexec -m /proc/104710/ns/mnt -- sh -c ps aux"}
      2023-07-16T08:20:46.841Z INFO chaos-daemon.daemon-server chaosdaemon/server.go:187 cmd output {"namespacedName": "chaos-mesh/hello-busybox", "output": "PID   USER     TIME  COMMAND\n    1 root      0:00 sh -c echo Container is Running ; sleep 3600\n"}
      2023-07-16T08:20:46.856Z INFO chaos-daemon.daemon-server chaosdaemon/server.go:187 ExecHelloWorldChaos {"namespacedName": "chaos-mesh/hello-busybox", "request": "container_id:\"docker://bab4f632a0358529f7d72d35e014b8c2ce57438102d99d6174dd9df52d093e99\""}
      2023-07-16T08:20:46.864Z INFO chaos-daemon.daemon-server.background-process-manager.process-builder pb/chaosdaemon.pb.go:4568 build command {"namespacedName": "chaos-mesh/hello-busybox", "command": "/usr/local/bin/nsexec -m /proc/104841/ns/mnt -- sh -c ps aux"}
      2023-07-16T08:20:46.867Z INFO chaos-daemon.daemon-server chaosdaemon/server.go:187 cmd output {"namespacedName": "chaos-mesh/hello-busybox", "output": "PID   USER     TIME  COMMAND\n    1 root      0:00 sh -c echo Container is Running ; sleep 3600\n"}

    Vous verrez deux lignes distinctes de ps aux, correspondant à deux Pods différents.

Prochaines étapes​

Si vous rencontrez des problèmes lors de ce processus, créez une issue dans le dépôt Chaos Mesh.

Si vous êtes curieux de comprendre le fonctionnement interne, consultez le controllers/README.md et le code des différents contrôleurs.

Vous êtes maintenant prêt à devenir un contributeur de Chaos Mesh ! Consultez les issues de Chaos Mesh pour trouver un good first issue et commencer !