der beste Weg in Kubernetes, um Fehlermeldungen zu erhalten, wenn Ressourcen von .json oder .yaml specifications instanziiert werden?

Question

Ich benutze Fabric8, um eine Cluster-Management-Schicht auf Kubernetes zu entwickeln, und ich bin verwirrt, was die "offiziellen" API ist, Benachrichtigungen von Fehlern zu erhalten, wenn Dinge schief gehen, wenn Instanierung Pods/rep-Controller & Dienste etc .

Im Abschnitt "Pod Deployment Code" habe ich eine abgespeckte Version dessen, was wir für Pods tun. Im Fall , dass alles richtig geht, ist unser Code in Ordnung. Wir setzen auf 'Uhren', wie Sie in der Methode deployPodWithWatch sehen können. Alles, was ich in dem gegebenen eventReceived Rückruf tue ist das Ereignis, aber unser eigentliches Code gedruckt wird eine Meldung wie diese auseinander brechen:

got action: 
    MODIFIED/
     Pod(apiVersion=v1, kind=Pod, metadata=...etc etc 
     status=PodStatus(
      conditions=[ 

und wählen Sie aus dem ‚Status‘ Element des Pod und wenn wir bekommen PodCondition (status = True, type = Ready), wir wissen , dass unser Pod erfolgreich implementiert wurde.

Im Happy Path Fall funktioniert das großartig. Und Sie können tatsächlich den Code mit der Variable k8sUrl auf die richtige URL für Ihre Website geliefert ausführen (hoffentlich Ihre k8s Installation erfordert keine Authentifizierung, die Site-spezifisch ist, so dass ich Code dafür nicht zur Verfügung gestellt).

Angenommen, Sie ändern die Variable imageName in "nginBoo". Es gibt keine öffentlichen Docker Bild dieses Namens, so, nachdem Sie den Code ausführen, Ihre Kubernetes Kontext auf den Namespace „Junk“ gesetzt, und machen einen

describe pod podboy 

Sie werden zwei Statusmeldungen am Ende sehen, mit die folgenden Werte für Grund/Nachricht

Reason  message 
failedSync Error syncing pod, skipping... 
failed  Failed to pull image "nginBoo": API error (500): 
      Error parsing reference: "nginBoo" 
      is not a valid repository/tag 

Ich möchte einen Watch Callback implementieren, so dass es diese Arten von Fehlern abfängt. Allerdings das einzige, was ich sehe, ist ‚MODIFIED‘ Ereignisse, wobei das Pod ein Feld wie folgt hat:

state=ContainerState(running=null, terminated=null, 
     waiting=ContainerStateWaiting(
      reason=API error (500): 
       Error parsing reference: 
        "nginBoo" is not a valid repository/tag 

Ich glaube, ich aus einem Grund-Code aussehen könnte, die die Zeichenfolge ‚API-Fehler‘ enthalten, aber dies scheint zu sehr eine Implementierung abhängig Hack sein - es könnte nicht alle Fälle abdecken, und vielleicht wird es unter meinen Füßen mit zukünftigen Versionen ändern. Ich hätte gerne einen 'offiziellen' Weg von herauszufinden, ob es einen Fehler gab, aber meine Suchen sind trocken - so dass ich demütig Anfrage Anleitung von Ihnen allen k8s Experten da draußen. Vielen Dank !

Pod Deployment-Code

import com.fasterxml.jackson.databind.ObjectMapper 
import scala.collection.JavaConverters._ 
import com.ning.http.client.ws.WebSocket 
import com.typesafe.scalalogging.StrictLogging 
import io.fabric8.kubernetes.api.model.{DoneableNamespace, Namespace, Pod, ReplicationController} 
import io.fabric8.kubernetes.client.DefaultKubernetesClient.ConfigBuilder 
import io.fabric8.kubernetes.client.Watcher.Action 
import io.fabric8.kubernetes.client.dsl.Resource 
import io.fabric8.kubernetes.client.{DefaultKubernetesClient, Watcher} 

object ErrorTest extends App with StrictLogging { 
    // corresponds to --insecure-skip-tls-verify=true, according to io.fabric8.kubernetes.api.model.Cluster 
    val trustCerts = true 
    val k8sUrl = "http://localhost:8080" 
    val namespaceName = "junk" // replace this with name of a namespace that you know exists 
    val imageName: String = "nginx" 

    def go(): Unit = { 
    val kube = getConnection 
    dumpNamespaces(kube) 
    deployPodWithWatch(kube, getPod(image = imageName)) 
    } 

    def deployPodWithWatch(kube: DefaultKubernetesClient, pod: Pod): Unit = { 
    kube.pods().inNamespace(namespaceName).create(pod) /* create the pod ! */ 
    val podWatchWebSocket: WebSocket =    /* create watch on the pod */ 
     kube.pods().inNamespace(namespaceName).withName(pod.getMetadata.getName).watch(getPodWatch) 
    } 

    def getPod(image: String): Pod = { 
    val jsonTemplate = 
     """ 
    |{ 
    | "kind": "Pod", 
    | "apiVersion": "v1", 
    | "metadata": { 
    | "name": "podboy", 
    | "labels": { 
    |  "app": "nginx" 
    | } 
    | }, 
    | "spec": { 
    | "containers": [ 
    |  { 
    |  "name": "podboy", 
    |  "image": "<image>", 
    |  "ports": [ 
    |  { 
    |   "containerPort": 80, 
    |   "protocol": "TCP" 
    |  } 
    |  ] 
    |  } 
    | ] 
    | } 
    |} 
     """. 
    stripMargin 
    val replacement: String = "image\": \"" + image 
    val json = jsonTemplate.replaceAll("image\": \"<image>", replacement) 
    System.out.println("json:" + json); 
    new ObjectMapper().readValue(json, classOf[Pod]) 
    } 

    def dumpNamespaces(kube: DefaultKubernetesClient): Unit = { 
    val namespaceNames = kube.namespaces().list().getItems.asScala.map { 
     (ns: Namespace) => { 
    ns.getMetadata.getName 
     } 
    } 
    System.out.println("namespaces are:" + namespaceNames); 
    } 

    def getConnection = { 
    val configBuilder = new ConfigBuilder() 
    val config = 
     configBuilder. 
    trustCerts(trustCerts). 
    masterUrl(k8sUrl). 
    build() 
    new DefaultKubernetesClient(config) 
    } 

    def getPodWatch: Watcher[Pod] = { 
    new Watcher[Pod]() { 
     def eventReceived(action: Action, watchedPod: Pod) { 
     System.out.println("got action: " + action + "/" + watchedPod) 
     } 
    } 
    } 

    go() 
} 

Answer 1

Ich würde vorschlagen, dass Sie einen Blick auf Ereignisse haben, finden Sie this topic für einige Hinweise. Im Allgemeinen sollte jedes Objekt Ereignisse generieren, die Sie beobachten und über solche Fehler informiert werden können.