{"id":3339,"date":"2020-10-29T15:32:19","date_gmt":"2020-10-29T15:32:19","guid":{"rendered":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/"},"modified":"2021-11-17T21:17:08","modified_gmt":"2021-11-17T21:17:08","slug":"kubernetes-fundamentals-part-2-how-to-use-health-checks","status":"publish","type":"post","link":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/","title":{"rendered":"Kubernetes Fundamentals, Part 2: How to Use Health Checks"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"3339\" class=\"elementor elementor-3339\" data-elementor-post-type=\"post\">\n\t\t\t\t\t\t<section class=\"elementor-section elementor-top-section elementor-element elementor-element-238f8d2a elementor-section-boxed elementor-section-height-default elementor-section-height-default qodef-elementor-content-no\" data-id=\"238f8d2a\" data-element_type=\"section\">\n\t\t\t\t\t\t<div class=\"elementor-container elementor-column-gap-default\">\n\t\t\t\t\t<div class=\"elementor-column elementor-col-100 elementor-top-column elementor-element elementor-element-7b888c3e\" data-id=\"7b888c3e\" data-element_type=\"column\">\n\t\t\t<div class=\"elementor-widget-wrap elementor-element-populated\">\n\t\t\t\t\t\t<div class=\"elementor-element elementor-element-e19550f elementor-widget elementor-widget-text-editor\" data-id=\"e19550f\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t<style>\/*! elementor - v3.21.0 - 25-04-2024 *\/\n.elementor-widget-text-editor.elementor-drop-cap-view-stacked .elementor-drop-cap{background-color:#69727d;color:#fff}.elementor-widget-text-editor.elementor-drop-cap-view-framed .elementor-drop-cap{color:#69727d;border:3px solid;background-color:transparent}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap{margin-top:8px}.elementor-widget-text-editor:not(.elementor-drop-cap-view-default) .elementor-drop-cap-letter{width:1em;height:1em}.elementor-widget-text-editor .elementor-drop-cap{float:left;text-align:center;line-height:1;font-size:50px}.elementor-widget-text-editor .elementor-drop-cap-letter{display:inline-block}<\/style>\t\t\t\t<p><a href=\"https:\/\/blog.newrelic.com\/engineering\/what-is-kubernetes\/\" target=\"_blank\" rel=\"noopener noreferrer\">Kubernetes<\/a>\u00a0is the leading orchestration platform for containerized applications. To manage containers effectively, Kubernetes needs a way to check their health to see if they are working correctly and receiving traffic. Kubernetes uses health checks\u2014also known as\u00a0<em>probes<\/em>\u2014to determine if instances of your app are running and responsive.<\/p><p>In this article, we\u2019ll discuss the different probe types and the various ways to use them.<\/p><h3>Why Probes are Important<\/h3><p>Distributed systems can be hard to manage. Since the separate components work independently, each part will keep running even after other components have failed. At some point, an application may crash. Or an application might be still in the initialization stage and not yet ready to receive and process requests.<\/p><p>You can only assert the system\u2019s health if all of its components are working. Using probes, you can determine whether a container is dead or alive, and decide if Kubernetes should temporarily prevent other containers from accessing it. Kubernetes verifies individual containers\u2019 health to determine the overall pod health.<\/p><h3>Types of Probes<\/h3><p>As you deploy and operate distributed applications, containers are created, started, run, and terminated. To check a container\u2019s health in the different stages of its lifecycle,\u00a0<a href=\"https:\/\/contentlab.com\/securing-secrets-in-kubernetes\/\">Kubernetes<\/a>\u00a0uses different types of probes.<\/p><ul style=\"font-size: 16px; background-color: #ffffff;\"><li style=\"font-size: 16px;\"><span style=\"font-weight: bolder;\">Liveness probes<\/span>\u00a0allow Kubernetes to check if your app is alive. The\u00a0<em>kubelet\u00a0<\/em>agent that runs on each node uses the liveness probes to ensure that the containers are running as expected. If a container app is no longer serving requests, kubelet will intervene and restart the container.For example, if an application is not responding and cannot make progress because of a deadlock, the liveness probe detects that it is faulty. Kubelet then terminates and restarts the container. Even if the application carries defects that cause further deadlocks, the restart will increase the container\u2019s availability. It also gives your developers time to identify the defects and resolve them later.<\/li><li style=\"font-size: 16px;\"><span style=\"font-weight: bolder;\">Readiness probes\u00a0<\/span>run during the entire lifecycle of the container. Kubernetes uses this probe to know when the container is ready to start accepting traffic. If a readiness probe fails, Kubernetes will stop routing traffic to the pod until the probe passes again.For example, a container may need to perform initialization tasks, including unzipping and indexing files and populating database tables. Until the startup process is completed, the container will not be able to receive or serve traffic. During this time, the readiness probe will fail, so Kubernetes will route requests to other containers.A pod is considered ready when all of its containers are ready. That helps Kubernetes control which pods are used as backends for services. If not ready, a pod is removed from service load balancers.<\/li><li style=\"font-size: 16px;\"><span style=\"font-weight: bolder;\">Startup probes<\/span>\u00a0are used to determine when a container application has been initialized successfully. If a startup probe fails, the pod is restarted.When pod containers take too long to become ready, readiness probes may fail repeatedly. In this case, containers risk being terminated by kubelet before they are up and running. This is where the startup probe comes to the rescue.The startup probe forces liveness and readiness checks to wait until it succeeds, so that the application startup is not compromised. That is especially beneficial for slow-starting legacy applications.<\/li><\/ul><h3>Creating Probes<\/h3><p>To create health check probes, you must issue requests against a container. There are three ways of implementing Kubernetes liveness, readiness, and startup probes:<\/p><ol style=\"font-size: 16px; background-color: #ffffff;\"><li style=\"font-size: 16px;\">Sending an HTTP request<\/li><li style=\"font-size: 16px;\">Running a command<\/li><li style=\"font-size: 16px;\">Opening a TCP socket<br \/><br \/><\/li><\/ol><h4 style=\"font-family: Sailec, sans-serif;\">HTTP Requests<\/h4><p>An HTTP request is a common and straightforward mechanism for creating a liveness probe. To expose an HTTP endpoint, you can implement any lightweight HTTP server in your container.<\/p><p>A Kubernetes probe will perform an HTTP GET request against your endpoint at the container\u2019s IP to verify whether your service is alive. If your endpoint returns a success code, kubelet will consider the container alive and healthy. Otherwise, kubelet will terminate and restart the container.<\/p><p>Suppose you have a container based on an image named k8s.gcr.io\/liveness. In that case, if you define a liveness probe that uses an HTTP GET request, your YAML configuration file would look similar to this snippet:<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-729c228 elementor-widget elementor-widget-code-highlight\" data-id=\"729c228\" data-element_type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"prismjs-default copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-javascript line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-javascript\">\n\t\t\t\t\t<xmp>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  labels:\r\n    test: liveness\r\n  name: liveness-http\r\nspec:\r\n  containers:\r\n  - name: liveness\r\n    image: k8s.gcr.io\/liveness\r\n    args:\r\n    - \/server\r\n    livenessProbe:\r\n      httpGet:\r\n        path: \/healthz\r\n        port: 8080\r\n        httpHeaders:\r\n        - name: Custom-Header\r\n          value: Awesome\r\n     initialDelaySeconds: 3\r\n     periodSeconds: 3<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-afc0fb3 elementor-widget elementor-widget-text-editor\" data-id=\"afc0fb3\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<p>The configuration defines a single-container pod with initialDelaySeconds and periodSeconds properties that tell kubelet to execute a liveness probe every 3 seconds and wait 3 seconds before performing the first probe. Kubelet will check whether the container is alive and healthy by sending requests to the \/healthz path on port\u00a0<code>8080<\/code>\u00a0and expect a success result code.<\/p><h4 style=\"font-family: Sailec, sans-serif;\">Commands<\/h4><p>When the HTTP requests are not suitable, you can use command probes.<\/p><p>Once you have a command probe configured, kubelet executes the\u00a0<code>cat \/tmp\/healthy<\/code>\u00a0command in the target container. Kubelet considers your container alive and healthy if the command succeeds. Otherwise,\u00a0<a href=\"https:\/\/contentlab.com\/securing-secrets-in-kubernetes\/\">Kubernetes<\/a>\u00a0terminates and restarts the container.<\/p><p>This is how your YAML configuration would look for a new pod that runs a container based on the k8s.gcr.io\/busybox image:<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-9620102 elementor-widget elementor-widget-code-highlight\" data-id=\"9620102\" data-element_type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"prismjs-default copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-javascript line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-javascript\">\n\t\t\t\t\t<xmp>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  labels:\r\n    test: liveness\r\n  name: liveness-exec\r\nspec:\r\n  containers:\r\n  - name: liveness\r\n    image: k8s.gcr.io\/busybox\r\n    args:\r\n    - \/bin\/sh\r\n    - -c\r\n    - touch \/tmp\/healthy; sleep 30; rm -rf \/tmp\/healthy; sleep 600\r\n    livenessProbe:\r\n      exec: \r\n        command:\r\n        - cat\r\n        - \/tmp\/healthy\r\n      initialDelaySeconds: 5\r\n      periodSeconds: 5<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-25131de elementor-widget elementor-widget-text-editor\" data-id=\"25131de\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<p>The above configuration defines a single container pod with the\u00a0<code>initialDelaySeconds<\/code>\u00a0and the periodSeconds keys tell kubelet to perform a liveness probe every 5 seconds and wait 5 seconds before the first probe is completed.<\/p><p>Kubelet will run the\u00a0<code>cat \/tmp\/healthy<\/code>\u00a0command in the container to execute a probe.<\/p><h4 style=\"font-family: Sailec, sans-serif;\">TCP Connections<\/h4><p>When a TCP socket probe is defined, Kubernetes tries to open a TCP connection on your container\u2019s specified port. If Kubernetes succeeds, the container is considered healthy. TCP probes are helpful when HTTP or command probes are not adequate. Scenarios where containers can benefit from TCP probes include gRPC and FTP services, where the TCP protocol infrastructure already exists.<\/p><p>With the following configuration, kubelet will try to open a socket to your container on the specified port.<\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-5f18bfa elementor-widget elementor-widget-code-highlight\" data-id=\"5f18bfa\" data-element_type=\"widget\" data-widget_type=\"code-highlight.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"prismjs-default copy-to-clipboard \">\n\t\t\t<pre data-line=\"\" class=\"highlight-height language-javascript line-numbers\">\n\t\t\t\t<code readonly=\"true\" class=\"language-javascript\">\n\t\t\t\t\t<xmp>apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: goproxy\r\n  labels:\r\n    app: goproxy\r\nspec:\r\n  containers:\r\n  - name: goproxy\r\n    image: k8s.gcr.io\/goproxy:0.1\r\n    ports:\r\n    - containerPort: 8080\r\n    readinessProbe:  \r\n      tcpSocket:\r\n        port: 8080\r\n      initialDelaySeconds: 5\r\n      periodSeconds: 10\r\n    livenessProbe:\r\n      tcpSocket:\r\n        port: 8080\r\n    initialDelaySeconds: 15\r\n    periodSeconds: 20<\/xmp>\n\t\t\t\t<\/code>\n\t\t\t<\/pre>\n\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-78392bd3 elementor-widget elementor-widget-text-editor\" data-id=\"78392bd3\" data-element_type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t<p><\/p>\n<pre><span style=\"color: var( --e-global-color-text ); font-family: var( --e-global-typography-text-font-family ), Sans-serif; font-weight: var( --e-global-typography-text-font-weight ); font-size: 1rem;\">The above configuration is similar to the HTTP check. It defines a readiness and a liveness probe. When the container starts, kubelet will wait 5 seconds to send the first readiness probe. After that, kubelet will keep checking the container readiness every 10 seconds.<\/span><br><\/pre>\n<h3>Monitoring Kubernetes health<\/h3>\n<p>Probes tell Kubernetes whether your containers are healthy, but they don\u2019t tell <em>you<\/em> anything.<\/p>\n<p>When you have many services running in Kubernetes pods deployed across many nodes, health and error monitoring can be difficult.<\/p>\n<p>As a developer or a DevOps specialist working with the Kubernetes platform, you might find New Relic an excellent tool for checking Kubernetes\u2019 health, gathering insights, and troubleshooting container issues.<\/p>\n<p><img fetchpriority=\"high\" decoding=\"async\" class=\"alignnone size-full wp-image-4328\" src=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/PodHealth.png\" alt=\"\" width=\"1200\" height=\"672\" srcset=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/PodHealth.png 1200w, https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/PodHealth-300x168.png 300w, https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/PodHealth-1024x573.png 1024w, https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/PodHealth-768x430.png 768w\" sizes=\"(max-width: 1200px) 100vw, 1200px\" \/><\/p>\n<p id=\"caption-attachment-52979\" class=\"wp-caption-text\">Kubernetes dashboard showing overall Pod status<\/p>\n<p>With open instrumentation, connected data, and programmability, the <a href=\"https:\/\/newrelic.com\/platform\" target=\"_blank\" rel=\"noopener noreferrer\">New Relic platform<\/a> offers full observability of your Kubernetes cluster <em>and<\/em> the services running in it via metrics, events, logs, and traces.<\/p>\n<h3>Wrapping Up<\/h3>\n<p>Health checks via probes are essential to ensure that your containers are good citizens in a cluster. Kubernetes uses liveness, readiness, and startup probes to decide when a container needs to be restarted, or a pod needs to be removed from service. That helps you keep your distributed system services reliable and available.<\/p>\n<p>As we\u2019ve seen, probes are too difficult to set up and use\u2014and now you know how to do it.<\/p>\n<p><em>This article was originally published on <a href=\"https:\/\/blog.newrelic.com\/engineering\/kubernetes-health-checks\/\">New Relic&#8217;s blog<\/a><\/em><\/p>\n<p><em><span class=\"TextRun SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\">If you\u2019re interested in developing expert technical content that performs, <\/span><\/span><a class=\"Hyperlink SCXW156001673 BCX2\" href=\"https:\/\/contentlab.com\/contact\/\" target=\"_blank\" rel=\"noreferrer noopener\"><span class=\"TextRun Underlined SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\" data-ccp-charstyle=\"Hyperlink\">let\u2019s have a conversation<\/span><\/span><\/a><span class=\"TextRun SCXW156001673 BCX2\" lang=\"EN-US\" xml:lang=\"EN-US\" data-contrast=\"none\"><span class=\"NormalTextRun SCXW156001673 BCX2\"> today.<\/span><\/span><\/em><\/p>\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"<p>Kubernetes uses health checks\u2014also known as probes\u2014to determine if instances of your app are running and responsive. In this article, we\u2019ll discuss the different probe types and the various ways to use them.<\/p>\n","protected":false},"author":3,"featured_media":4893,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[19,278,18],"tags":[298,299],"hashtags":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v22.5 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab\" \/>\n<meta property=\"og:description\" content=\"Kubernetes uses health checks\u2014also known as probes\u2014to determine if instances of your app are running and responsive. In this article, we\u2019ll discuss the different probe types and the various ways to use them.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks\" \/>\n<meta property=\"og:site_name\" content=\"Technical Content Marketing | ContentLab\" \/>\n<meta property=\"article:published_time\" content=\"2020-10-29T15:32:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-11-17T21:17:08+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1746\" \/>\n\t<meta property=\"og:image:height\" content=\"530\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"ContentLab\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@ContentLabIO\" \/>\n<meta name=\"twitter:site\" content=\"@ContentLabIO\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"ContentLab\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#article\",\"isPartOf\":{\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/\"},\"author\":{\"name\":\"ContentLab\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532\"},\"headline\":\"Kubernetes Fundamentals, Part 2: How to Use Health Checks\",\"datePublished\":\"2020-10-29T15:32:19+00:00\",\"dateModified\":\"2021-11-17T21:17:08+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/\"},\"wordCount\":1158,\"publisher\":{\"@id\":\"https:\/\/contentlab.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage\"},\"thumbnailUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png\",\"keywords\":[\"DevOps\",\"Kubernetes\"],\"articleSection\":[\"Containers\",\"Hands-on Tutorial\",\"Portfolio\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/\",\"url\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks\",\"name\":\"Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab\",\"isPartOf\":{\"@id\":\"https:\/\/contentlab.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage\"},\"image\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage\"},\"thumbnailUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png\",\"datePublished\":\"2020-10-29T15:32:19+00:00\",\"dateModified\":\"2021-11-17T21:17:08+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage\",\"url\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png\",\"contentUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png\",\"width\":1746,\"height\":530},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/contentlab.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Kubernetes Fundamentals, Part 2: How to Use Health Checks\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/contentlab.com\/#website\",\"url\":\"https:\/\/contentlab.com\/\",\"name\":\"Technical Content Marketing | ContentLab\",\"description\":\"Technical Content Marketing Done Right.\",\"publisher\":{\"@id\":\"https:\/\/contentlab.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/contentlab.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/contentlab.com\/#organization\",\"name\":\"ContentLab.io\",\"url\":\"https:\/\/contentlab.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png\",\"contentUrl\":\"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png\",\"width\":768,\"height\":768,\"caption\":\"ContentLab.io\"},\"image\":{\"@id\":\"https:\/\/contentlab.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/x.com\/ContentLabIO\",\"https:\/\/www.linkedin.com\/company\/17893315\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532\",\"name\":\"ContentLab\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/contentlab.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g\",\"caption\":\"ContentLab\"},\"description\":\"ContentLab provides high-quality written articles, tutorials, courses, and other technical marketing materials to industry leaders. We create no-nonsense tech content that\u2019s purpose-built to attract, educate, and engage your technical audience.\",\"sameAs\":[\"https:\/\/contentlab.op\"],\"url\":\"https:\/\/contentlab.com\/author\/contentlab\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks","og_locale":"en_US","og_type":"article","og_title":"Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab","og_description":"Kubernetes uses health checks\u2014also known as probes\u2014to determine if instances of your app are running and responsive. In this article, we\u2019ll discuss the different probe types and the various ways to use them.","og_url":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks","og_site_name":"Technical Content Marketing | ContentLab","article_published_time":"2020-10-29T15:32:19+00:00","article_modified_time":"2021-11-17T21:17:08+00:00","og_image":[{"width":1746,"height":530,"url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","type":"image\/png"}],"author":"ContentLab","twitter_card":"summary_large_image","twitter_creator":"@ContentLabIO","twitter_site":"@ContentLabIO","twitter_misc":{"Written by":"ContentLab","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#article","isPartOf":{"@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/"},"author":{"name":"ContentLab","@id":"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532"},"headline":"Kubernetes Fundamentals, Part 2: How to Use Health Checks","datePublished":"2020-10-29T15:32:19+00:00","dateModified":"2021-11-17T21:17:08+00:00","mainEntityOfPage":{"@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/"},"wordCount":1158,"publisher":{"@id":"https:\/\/contentlab.com\/#organization"},"image":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage"},"thumbnailUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","keywords":["DevOps","Kubernetes"],"articleSection":["Containers","Hands-on Tutorial","Portfolio"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/contentlab.com\/kubernetes-fundamentals-part-2-how-to-use-health-checks\/","url":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks","name":"Kubernetes Fundamentals, Part 2: How to Use Health Checks &#183; Technical Content Marketing | ContentLab","isPartOf":{"@id":"https:\/\/contentlab.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage"},"image":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage"},"thumbnailUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","datePublished":"2020-10-29T15:32:19+00:00","dateModified":"2021-11-17T21:17:08+00:00","breadcrumb":{"@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#primaryimage","url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","contentUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","width":1746,"height":530},{"@type":"BreadcrumbList","@id":"https:\/\/newrelic.com\/blog\/how-to-relic\/kubernetes-health-checks#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/contentlab.com\/"},{"@type":"ListItem","position":2,"name":"Kubernetes Fundamentals, Part 2: How to Use Health Checks"}]},{"@type":"WebSite","@id":"https:\/\/contentlab.com\/#website","url":"https:\/\/contentlab.com\/","name":"Technical Content Marketing | ContentLab","description":"Technical Content Marketing Done Right.","publisher":{"@id":"https:\/\/contentlab.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/contentlab.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/contentlab.com\/#organization","name":"ContentLab.io","url":"https:\/\/contentlab.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/contentlab.com\/#\/schema\/logo\/image\/","url":"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png","contentUrl":"https:\/\/contentlab.com\/wp-content\/uploads\/2021\/11\/favicon-1.png","width":768,"height":768,"caption":"ContentLab.io"},"image":{"@id":"https:\/\/contentlab.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/x.com\/ContentLabIO","https:\/\/www.linkedin.com\/company\/17893315\/"]},{"@type":"Person","@id":"https:\/\/contentlab.com\/#\/schema\/person\/e1b8cacc1019e83e8d6cd9ab1a049532","name":"ContentLab","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/contentlab.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/3929e740ba8fe876f001a63220500e8e?s=96&d=mm&r=g","caption":"ContentLab"},"description":"ContentLab provides high-quality written articles, tutorials, courses, and other technical marketing materials to industry leaders. We create no-nonsense tech content that\u2019s purpose-built to attract, educate, and engage your technical audience.","sameAs":["https:\/\/contentlab.op"],"url":"https:\/\/contentlab.com\/author\/contentlab\/"}]}},"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/contentlab.com\/wp-content\/uploads\/2020\/10\/2.png","_links":{"self":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3339"}],"collection":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/comments?post=3339"}],"version-history":[{"count":6,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3339\/revisions"}],"predecessor-version":[{"id":5456,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/posts\/3339\/revisions\/5456"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/media\/4893"}],"wp:attachment":[{"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/media?parent=3339"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/categories?post=3339"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/tags?post=3339"},{"taxonomy":"hashtags","embeddable":true,"href":"https:\/\/contentlab.com\/wp-json\/wp\/v2\/hashtags?post=3339"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}