Kubernetes Oglądaj Pod Wydarzenia z api

Question

Jesteśmy zainteresowani uruchomieniem niektórych poleceń jako strąków i usług, ponieważ zaczynają się lub kończą. Używanie przechwytów cyklu życia w plikach yml nie działa dla nas, ponieważ te polecenia nie są opcjonalne. Rozważaliśmy uruchomienie podnośnika obserwującego, który używa apia zegarka do uruchamiania tych poleceń. Ale nie możemy dowiedzieć się, jak korzystać z interfejsu API zegarka, aby nie wysyłał ciągle tych samych zdarzeń. Czy istnieje sposób na poinformowanie Api zegarka, aby wysyłał tylko nowe zdarzenia od momentu otwarcia połączenia? Jeśli oczekiwanie na stateful watch api jest nieuzasadnione, czy będzie możliwe podanie go w postaci znacznika czasu lub monotonicznie rosnącego identyfikatora, aby uniknąć dostrzegania już zauważonych zdarzeń?

Zasadniczo, co teraz robimy, uruchamiamy strąk z procesem demona komunikującym się z interfejsem API. możemy znaleźć wydarzenia jako strumień. Ale jesteśmy zainteresowani uruchomieniem jakiegoś zadania po utworzeniu lub usunięciu kapsuły.

Answer 1

Znalazłem odpowiedź. W przypadku, gdy ktoś inny patrzy.

Jest znacznie lepszy system do oglądania zasobów i obsługi zdarzeń z niestandardowych zadań z pkg/controller/frameworkpackage

znalazłem krok takiego,

1. initiate a framework.NewInFormer 
2. Run the controller 
3. the NewInFormer loads with your custom event handlers that will call when the events occured. 

Answer 2

Polecam używanie client z repozytorium Kube. Dlaczego lifecycle hooks nie działa w twoim przypadku użycia?

Answer 3

W przypadku, gdy będzie już w klastrze można zrobić tak to w golang:

package main 

import (
    "fmt" 
    "time" 

    "k8s.io/client-go/kubernetes" 
    "k8s.io/client-go/pkg/api/v1" 
    "k8s.io/client-go/tools/cache" 
    "k8s.io/client-go/pkg/fields" 
    "k8s.io/client-go/rest" 
) 

func main() { 
    config, err := rest.InClusterConfig() 
    if err != nil { 
     panic(err.Error()) 
    } 

    clientset, err := kubernetes.NewForConfig(config) 
    if err != nil { 
     panic(err.Error()) 
    } 

    watchlist := cache.NewListWatchFromClient(clientset.Core().RESTClient(), "pods", v1.NamespaceDefault, 
     fields.Everything()) 
    _, controller := cache.NewInformer(
     watchlist, 
     &v1.Pod{}, 
     time.Second * 0, 
     cache.ResourceEventHandlerFuncs{ 
      AddFunc: func(obj interface{}) { 
       fmt.Printf("add: %s \n", obj) 
      }, 
      DeleteFunc: func(obj interface{}) { 
       fmt.Printf("delete: %s \n", obj) 
      }, 
      UpdateFunc:func(oldObj, newObj interface{}) { 
       fmt.Printf("old: %s, new: %s \n", oldObj, newObj) 
      }, 
     }, 
    ) 
    stop := make(chan struct{}) 
    go controller.Run(stop) 
} 

Answer 4

Mówisz, że polecenia przechwytywania cyklu życia nie są opcjonalne, ale w rzeczywistości są opcjonalne.

Hook handler implementations 
Containers can access a hook by implementing and registering a handler for that hook. There are two types of hook handlers that can be implemented for Containers: 
Exec - Executes a specific command, such as pre-stop.sh, inside the cgroups and namespaces of the Container. Resources consumed by the command are counted against the Container. 
HTTP - Executes an HTTP request against a specific endpoint on the Container. 

stąd: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/

Answer 5

Run Kube proxy użyć zwijania bez uwierzytelniania

kubectl proxy 

Lista wszystkich zdarzeń z zegarka;

curl -s 127.0.0.1:8001/api/v1/watch/events 

Uruchom curl, aby obejrzeć zdarzenia i przefiltrować je za pomocą jq, aby rozpocząć i zatrzymać pod przyciskiem.

curl -s 127.0.0.1:8001/api/v1/watch/events | jq --raw-output \ 'if .object.reason == "Started" then . elif .object.reason == "Killing" then . else empty end | [.object.firstTimestamp, .object.reason, .object.metadata.namespace, .object.metadata.name] | @csv' 

More details