implement :grpc probe action

api/openapi-spec/swagger.json

@@ -6538,6 +6538,23 @@
       ],
       "type": "object"
     },
+    "io.k8s.api.core.v1.GRPCAction": {
+      "properties": {
+        "port": {
+          "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "service": {
+          "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+          "type": "string"
+        }
+      },
+      "required": [
+        "port"
+      ],
+      "type": "object"
+    },
     "io.k8s.api.core.v1.GitRepoVolumeSource": {
       "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
       "properties": {
@@ -8979,6 +8996,10 @@
           "format": "int32",
           "type": "integer"
         },
+        "gRPC": {
+          "$ref": "#/definitions/io.k8s.api.core.v1.GRPCAction",
+          "description": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate."
+        },
         "httpGet": {
           "$ref": "#/definitions/io.k8s.api.core.v1.HTTPGetAction",
           "description": "HTTPGet specifies the http request to perform."

api/openapi-spec/v3/api__v1_openapi.json

@@ -24507,6 +24507,25 @@
           }
         }
       },
+      "io.k8s.api.core.v1.GRPCAction": {
+        "type": "object",
+        "required": [
+          "port"
+        ],
+        "properties": {
+          "port": {
+            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+            "type": "integer",
+            "format": "int32",
+            "default": 0
+          },
+          "service": {
+            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+            "type": "string",
+            "default": ""
+          }
+        }
+      },
       "io.k8s.api.core.v1.GitRepoVolumeSource": {
         "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
         "type": "object",
@@ -27113,6 +27132,10 @@
             "type": "integer",
             "format": "int32"
           },
+          "gRPC": {
+            "description": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.",
+            "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction"
+          },
           "httpGet": {
             "description": "HTTPGet specifies the http request to perform.",
             "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction"

api/openapi-spec/v3/apis__apps__v1_openapi.json

@@ -9952,6 +9952,25 @@
           }
         }
       },
+      "io.k8s.api.core.v1.GRPCAction": {
+        "type": "object",
+        "required": [
+          "port"
+        ],
+        "properties": {
+          "port": {
+            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+            "type": "integer",
+            "format": "int32",
+            "default": 0
+          },
+          "service": {
+            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+            "type": "string",
+            "default": ""
+          }
+        }
+      },
       "io.k8s.api.core.v1.GitRepoVolumeSource": {
         "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
         "type": "object",
@@ -11101,6 +11120,10 @@
             "type": "integer",
             "format": "int32"
           },
+          "gRPC": {
+            "description": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.",
+            "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction"
+          },
           "httpGet": {
             "description": "HTTPGet specifies the http request to perform.",
             "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction"

api/openapi-spec/v3/apis__batch__v1_openapi.json

@@ -4355,6 +4355,25 @@
           }
         }
       },
+      "io.k8s.api.core.v1.GRPCAction": {
+        "type": "object",
+        "required": [
+          "port"
+        ],
+        "properties": {
+          "port": {
+            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+            "type": "integer",
+            "format": "int32",
+            "default": 0
+          },
+          "service": {
+            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+            "type": "string",
+            "default": ""
+          }
+        }
+      },
       "io.k8s.api.core.v1.GitRepoVolumeSource": {
         "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
         "type": "object",
@@ -5409,6 +5428,10 @@
             "type": "integer",
             "format": "int32"
           },
+          "gRPC": {
+            "description": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.",
+            "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction"
+          },
           "httpGet": {
             "description": "HTTPGet specifies the http request to perform.",
             "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction"

api/openapi-spec/v3/apis__batch__v1beta1_openapi.json

@@ -2663,6 +2663,25 @@
           }
         }
       },
+      "io.k8s.api.core.v1.GRPCAction": {
+        "type": "object",
+        "required": [
+          "port"
+        ],
+        "properties": {
+          "port": {
+            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+            "type": "integer",
+            "format": "int32",
+            "default": 0
+          },
+          "service": {
+            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+            "type": "string",
+            "default": ""
+          }
+        }
+      },
       "io.k8s.api.core.v1.GitRepoVolumeSource": {
         "description": "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
         "type": "object",
@@ -3717,6 +3736,10 @@
             "type": "integer",
             "format": "int32"
           },
+          "gRPC": {
+            "description": "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.",
+            "$ref": "#/components/schemas/io.k8s.api.core.v1.GRPCAction"
+          },
           "httpGet": {
             "description": "HTTPGet specifies the http request to perform.",
             "$ref": "#/components/schemas/io.k8s.api.core.v1.HTTPGetAction"

pkg/apis/apps/v1/zz_generated.defaults.go

@@ -127,18 +127,36 @@ func SetObjectDefaults_DaemonSet(in *v1.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -177,18 +195,36 @@ func SetObjectDefaults_DaemonSet(in *v1.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -227,18 +263,36 @@ func SetObjectDefaults_DaemonSet(in *v1.DaemonSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -348,18 +402,36 @@ func SetObjectDefaults_Deployment(in *v1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -398,18 +470,36 @@ func SetObjectDefaults_Deployment(in *v1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -448,18 +538,36 @@ func SetObjectDefaults_Deployment(in *v1.Deployment) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -569,18 +677,36 @@ func SetObjectDefaults_ReplicaSet(in *v1.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -619,18 +745,36 @@ func SetObjectDefaults_ReplicaSet(in *v1.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -669,18 +813,36 @@ func SetObjectDefaults_ReplicaSet(in *v1.ReplicaSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -790,18 +952,36 @@ func SetObjectDefaults_StatefulSet(in *v1.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -840,18 +1020,36 @@ func SetObjectDefaults_StatefulSet(in *v1.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -890,18 +1088,36 @@ func SetObjectDefaults_StatefulSet(in *v1.StatefulSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/apps/v1beta1/zz_generated.defaults.go

@@ -123,18 +123,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -173,18 +191,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -223,18 +259,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -344,18 +398,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta1.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -394,18 +466,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta1.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -444,18 +534,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta1.StatefulSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/apps/v1beta2/zz_generated.defaults.go

@@ -127,18 +127,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta2.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -177,18 +195,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta2.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -227,18 +263,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta2.DaemonSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -348,18 +402,36 @@ func SetObjectDefaults_Deployment(in *v1beta2.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -398,18 +470,36 @@ func SetObjectDefaults_Deployment(in *v1beta2.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -448,18 +538,36 @@ func SetObjectDefaults_Deployment(in *v1beta2.Deployment) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -569,18 +677,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta2.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -619,18 +745,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta2.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -669,18 +813,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta2.ReplicaSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -790,18 +952,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta2.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -840,18 +1020,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta2.StatefulSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -890,18 +1088,36 @@ func SetObjectDefaults_StatefulSet(in *v1beta2.StatefulSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/batch/v1/zz_generated.defaults.go

@@ -123,18 +123,36 @@ func SetObjectDefaults_CronJob(in *v1.CronJob) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -173,18 +191,36 @@ func SetObjectDefaults_CronJob(in *v1.CronJob) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -223,18 +259,36 @@ func SetObjectDefaults_CronJob(in *v1.CronJob) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -344,18 +398,36 @@ func SetObjectDefaults_Job(in *v1.Job) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -394,18 +466,36 @@ func SetObjectDefaults_Job(in *v1.Job) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -444,18 +534,36 @@ func SetObjectDefaults_Job(in *v1.Job) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/batch/v1beta1/zz_generated.defaults.go

@@ -122,18 +122,36 @@ func SetObjectDefaults_CronJob(in *v1beta1.CronJob) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -172,18 +190,36 @@ func SetObjectDefaults_CronJob(in *v1beta1.CronJob) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -222,18 +258,36 @@ func SetObjectDefaults_CronJob(in *v1beta1.CronJob) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -342,18 +396,36 @@ func SetObjectDefaults_JobTemplate(in *v1beta1.JobTemplate) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -392,18 +464,36 @@ func SetObjectDefaults_JobTemplate(in *v1beta1.JobTemplate) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -442,18 +532,36 @@ func SetObjectDefaults_JobTemplate(in *v1beta1.JobTemplate) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/core/fuzzer/fuzzer.go

@@ -538,5 +538,11 @@ var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
 				e.Series.LastObservedTime = metav1.MicroTime{Time: time.Unix(3, 3000)}
 			}
 		},
+		func(j *core.GRPCAction, c fuzz.Continue) {
+			empty := ""
+			if j.Service == nil {
+				j.Service = &empty
+			}
+		},
 	}
 }

pkg/apis/core/types.go

@@ -2241,6 +2241,12 @@ type ProbeHandler struct {
 	// TCPSocket specifies an action involving a TCP port.
 	// +optional
 	TCPSocket *TCPSocketAction
+
+	// GRPC specifies an action involving a GRPC port.
+	// This is an alpha field and requires enabling GRPCContainerProbe feature gate.
+	// +featureGate=GRPCContainerProbe
+	// +optional
+	GRPC *GRPCAction
 }
 
 // LifecycleHandler defines a specific action that should be taken in a lifecycle
@@ -2259,6 +2265,19 @@ type LifecycleHandler struct {
 	TCPSocket *TCPSocketAction
 }
 
+type GRPCAction struct {
+	// Port number of the gRPC service.
+	// Note: Number must be in the range 1 to 65535.
+	Port int32
+
+	// Service is the name of the service to place in the gRPC HealthCheckRequest
+	// (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
+	//
+	// If this is not specified, the default behavior is to probe the server's overall health status.
+	// +optional
+	Service *string
+}
+
 // Lifecycle describes actions that the management system should take in response to container lifecycle
 // events.  For the PostStart and PreStop lifecycle handlers, management of the container blocks
 // until the action is complete, unless the container process fails, in which case the handler is aborted.

pkg/apis/core/v1/defaults_test.go

@@ -78,7 +78,22 @@ func TestWorkloadDefaults(t *testing.T) {
 		".Spec.Containers[0].StartupProbe.TimeoutSeconds":                "1",
 		".Spec.Containers[0].TerminationMessagePath":                     `"/dev/termination-log"`,
 		".Spec.Containers[0].TerminationMessagePolicy":                   `"File"`,
+		".Spec.Containers[0].LivenessProbe.ProbeHandler.GRPC.Service":    `""`,
+		".Spec.Containers[0].ReadinessProbe.ProbeHandler.GRPC.Service":   `""`,
+		".Spec.Containers[0].StartupProbe.ProbeHandler.GRPC.Service":     `""`,
 		".Spec.DNSPolicy": `"ClusterFirst"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Path":    `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Scheme":  `"HTTP"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Path":   `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Scheme": `"HTTP"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Path":     `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Scheme":   `"HTTP"`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Path":                                  `"/"`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Scheme":                                `"HTTP"`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Path":                                 `"/"`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Scheme":                               `"HTTP"`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Path":                                   `"/"`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Scheme":                                 `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Env[0].ValueFrom.FieldRef.APIVersion":       `"v1"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ImagePullPolicy":                            `"IfNotPresent"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet.Path":           `"/"`,
@@ -86,21 +101,18 @@ func TestWorkloadDefaults(t *testing.T) {
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet.Path":             `"/"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet.Scheme":           `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.FailureThreshold":             "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Path":    `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service":    `""`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Scheme":  `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.PeriodSeconds":                "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.SuccessThreshold":             "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.TimeoutSeconds":               "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Ports[0].Protocol":                          `"TCP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.FailureThreshold":            "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Path":   `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service":   `""`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Scheme": `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.PeriodSeconds":               "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.SuccessThreshold":            "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.TimeoutSeconds":              "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.FailureThreshold":              "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Path":     `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service":     `""`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Scheme":   `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.PeriodSeconds":                 "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.SuccessThreshold":              "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.TimeoutSeconds":                "1",
@@ -113,21 +125,18 @@ func TestWorkloadDefaults(t *testing.T) {
 		".Spec.InitContainers[0].Lifecycle.PreStop.HTTPGet.Path":                                           `"/"`,
 		".Spec.InitContainers[0].Lifecycle.PreStop.HTTPGet.Scheme":                                         `"HTTP"`,
 		".Spec.InitContainers[0].LivenessProbe.FailureThreshold":                                           `3`,
-		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Path":                                  `"/"`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.GRPC.Service":                                  `""`,
-		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Scheme":                                `"HTTP"`,
 		".Spec.InitContainers[0].LivenessProbe.PeriodSeconds":                                              `10`,
 		".Spec.InitContainers[0].LivenessProbe.SuccessThreshold":                                           `1`,
 		".Spec.InitContainers[0].LivenessProbe.TimeoutSeconds":                                             `1`,
 		".Spec.InitContainers[0].Ports[0].Protocol":                                                        `"TCP"`,
 		".Spec.InitContainers[0].ReadinessProbe.FailureThreshold":                                          `3`,
-		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Path":                                 `"/"`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.GRPC.Service":                                 `""`,
-		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Scheme":                               `"HTTP"`,
 		".Spec.InitContainers[0].ReadinessProbe.PeriodSeconds":                                             `10`,
 		".Spec.InitContainers[0].ReadinessProbe.SuccessThreshold":                                          `1`,
 		".Spec.InitContainers[0].ReadinessProbe.TimeoutSeconds":                                            `1`,
 		".Spec.InitContainers[0].StartupProbe.FailureThreshold":                                            "3",
-		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Path":                                   `"/"`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.GRPC.Service":                                   `""`,
-		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Scheme":                                 `"HTTP"`,
 		".Spec.InitContainers[0].StartupProbe.PeriodSeconds":                                               "10",
 		".Spec.InitContainers[0].StartupProbe.SuccessThreshold":                                            "1",
 		".Spec.InitContainers[0].StartupProbe.TimeoutSeconds":                                              "1",
@@ -203,6 +212,9 @@ func TestPodDefaults(t *testing.T) {
 		".Spec.Containers[0].StartupProbe.TimeoutSeconds":                "1",
 		".Spec.Containers[0].TerminationMessagePath":                     `"/dev/termination-log"`,
 		".Spec.Containers[0].TerminationMessagePolicy":                   `"File"`,
+		".Spec.Containers[0].LivenessProbe.ProbeHandler.GRPC.Service":    `""`,
+		".Spec.Containers[0].ReadinessProbe.ProbeHandler.GRPC.Service":   `""`,
+		".Spec.Containers[0].StartupProbe.ProbeHandler.GRPC.Service":     `""`,
 		".Spec.DNSPolicy":          `"ClusterFirst"`,
 		".Spec.EnableServiceLinks": `true`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Env[0].ValueFrom.FieldRef.APIVersion":       `"v1"`,
@@ -212,21 +224,15 @@ func TestPodDefaults(t *testing.T) {
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet.Path":             `"/"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet.Scheme":           `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.FailureThreshold":             "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Path":    `"/"`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Scheme":  `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.PeriodSeconds":                "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.SuccessThreshold":             "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.TimeoutSeconds":               "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.Ports[0].Protocol":                          `"TCP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.FailureThreshold":            "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Path":   `"/"`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Scheme": `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.PeriodSeconds":               "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.SuccessThreshold":            "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.TimeoutSeconds":              "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.FailureThreshold":              "3",
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Path":     `"/"`,
-		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Scheme":   `"HTTP"`,
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.PeriodSeconds":                 "10",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.SuccessThreshold":              "1",
 		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.TimeoutSeconds":                "1",
@@ -239,15 +245,11 @@ func TestPodDefaults(t *testing.T) {
 		".Spec.InitContainers[0].Lifecycle.PreStop.HTTPGet.Path":                                           `"/"`,
 		".Spec.InitContainers[0].Lifecycle.PreStop.HTTPGet.Scheme":                                         `"HTTP"`,
 		".Spec.InitContainers[0].LivenessProbe.FailureThreshold":                                           `3`,
-		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Path":                                  `"/"`,
-		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Scheme":                                `"HTTP"`,
 		".Spec.InitContainers[0].LivenessProbe.PeriodSeconds":                                              `10`,
 		".Spec.InitContainers[0].LivenessProbe.SuccessThreshold":                                           `1`,
 		".Spec.InitContainers[0].LivenessProbe.TimeoutSeconds":                                             `1`,
 		".Spec.InitContainers[0].Ports[0].Protocol":                                                        `"TCP"`,
 		".Spec.InitContainers[0].ReadinessProbe.FailureThreshold":                                          `3`,
-		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Path":                                 `"/"`,
-		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Scheme":                               `"HTTP"`,
 		".Spec.InitContainers[0].ReadinessProbe.PeriodSeconds":                                             `10`,
 		".Spec.InitContainers[0].ReadinessProbe.SuccessThreshold":                                          `1`,
 		".Spec.InitContainers[0].ReadinessProbe.TimeoutSeconds":                                            `1`,
@@ -255,11 +257,27 @@ func TestPodDefaults(t *testing.T) {
 		".Spec.InitContainers[0].TerminationMessagePath":                                                   `"/dev/termination-log"`,
 		".Spec.InitContainers[0].TerminationMessagePolicy":                                                 `"File"`,
 		".Spec.InitContainers[0].StartupProbe.FailureThreshold":                                            "3",
-		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Path":                                   `"/"`,
-		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Scheme":                                 `"HTTP"`,
 		".Spec.InitContainers[0].StartupProbe.PeriodSeconds":                                               "10",
 		".Spec.InitContainers[0].StartupProbe.SuccessThreshold":                                            "1",
 		".Spec.InitContainers[0].StartupProbe.TimeoutSeconds":                                              "1",
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service":    `""`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Path":    `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet.Scheme":  `"HTTP"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service":   `""`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Path":   `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet.Scheme": `"HTTP"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service":     `""`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Path":     `"/"`,
+		".Spec.EphemeralContainers[0].EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet.Scheme":   `"HTTP"`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.GRPC.Service":                                  `""`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Path":                                  `"/"`,
+		".Spec.InitContainers[0].LivenessProbe.ProbeHandler.HTTPGet.Scheme":                                `"HTTP"`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.GRPC.Service":                                 `""`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Path":                                 `"/"`,
+		".Spec.InitContainers[0].ReadinessProbe.ProbeHandler.HTTPGet.Scheme":                               `"HTTP"`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.GRPC.Service":                                   `""`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Path":                                   `"/"`,
+		".Spec.InitContainers[0].StartupProbe.ProbeHandler.HTTPGet.Scheme":                                 `"HTTP"`,
 		".Spec.RestartPolicy":                                                                         `"Always"`,
 		".Spec.SchedulerName":                                                                         `"default-scheduler"`,
 		".Spec.SecurityContext":                                                                       `{}`,

pkg/apis/core/v1/zz_generated.conversion.go

@@ -642,6 +642,16 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddGeneratedConversionFunc((*v1.GRPCAction)(nil), (*core.GRPCAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_v1_GRPCAction_To_core_GRPCAction(a.(*v1.GRPCAction), b.(*core.GRPCAction), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddGeneratedConversionFunc((*core.GRPCAction)(nil), (*v1.GRPCAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_core_GRPCAction_To_v1_GRPCAction(a.(*core.GRPCAction), b.(*v1.GRPCAction), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddGeneratedConversionFunc((*v1.GitRepoVolumeSource)(nil), (*core.GitRepoVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(a.(*v1.GitRepoVolumeSource), b.(*core.GitRepoVolumeSource), scope)
 	}); err != nil {
@@ -3827,6 +3837,28 @@ func Convert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSou
 	return autoConvert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in, out, s)
 }
 
+func autoConvert_v1_GRPCAction_To_core_GRPCAction(in *v1.GRPCAction, out *core.GRPCAction, s conversion.Scope) error {
+	out.Port = in.Port
+	out.Service = (*string)(unsafe.Pointer(in.Service))
+	return nil
+}
+
+// Convert_v1_GRPCAction_To_core_GRPCAction is an autogenerated conversion function.
+func Convert_v1_GRPCAction_To_core_GRPCAction(in *v1.GRPCAction, out *core.GRPCAction, s conversion.Scope) error {
+	return autoConvert_v1_GRPCAction_To_core_GRPCAction(in, out, s)
+}
+
+func autoConvert_core_GRPCAction_To_v1_GRPCAction(in *core.GRPCAction, out *v1.GRPCAction, s conversion.Scope) error {
+	out.Port = in.Port
+	out.Service = (*string)(unsafe.Pointer(in.Service))
+	return nil
+}
+
+// Convert_core_GRPCAction_To_v1_GRPCAction is an autogenerated conversion function.
+func Convert_core_GRPCAction_To_v1_GRPCAction(in *core.GRPCAction, out *v1.GRPCAction, s conversion.Scope) error {
+	return autoConvert_core_GRPCAction_To_v1_GRPCAction(in, out, s)
+}
+
 func autoConvert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(in *v1.GitRepoVolumeSource, out *core.GitRepoVolumeSource, s conversion.Scope) error {
 	out.Repository = in.Repository
 	out.Revision = in.Revision
@@ -6515,6 +6547,7 @@ func autoConvert_v1_ProbeHandler_To_core_ProbeHandler(in *v1.ProbeHandler, out *
 	out.Exec = (*core.ExecAction)(unsafe.Pointer(in.Exec))
 	out.HTTPGet = (*core.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
 	out.TCPSocket = (*core.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
+	out.GRPC = (*core.GRPCAction)(unsafe.Pointer(in.GRPC))
 	return nil
 }
 
@@ -6527,6 +6560,7 @@ func autoConvert_core_ProbeHandler_To_v1_ProbeHandler(in *core.ProbeHandler, out
 	out.Exec = (*v1.ExecAction)(unsafe.Pointer(in.Exec))
 	out.HTTPGet = (*v1.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
 	out.TCPSocket = (*v1.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
+	out.GRPC = (*v1.GRPCAction)(unsafe.Pointer(in.GRPC))
 	return nil
 }
 

pkg/apis/core/v1/zz_generated.defaults.go

@@ -257,18 +257,36 @@ func SetObjectDefaults_Pod(in *v1.Pod) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -307,18 +325,36 @@ func SetObjectDefaults_Pod(in *v1.Pod) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -357,18 +393,36 @@ func SetObjectDefaults_Pod(in *v1.Pod) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -477,18 +531,36 @@ func SetObjectDefaults_PodTemplate(in *v1.PodTemplate) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -527,18 +599,36 @@ func SetObjectDefaults_PodTemplate(in *v1.PodTemplate) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -577,18 +667,36 @@ func SetObjectDefaults_PodTemplate(in *v1.PodTemplate) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -699,18 +807,36 @@ func SetObjectDefaults_ReplicationController(in *v1.ReplicationController) {
 				if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.LivenessProbe.ProbeHandler.GRPC != nil {
+					if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.ReadinessProbe != nil {
 				SetDefaults_Probe(a.ReadinessProbe)
 				if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+					if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.StartupProbe != nil {
 				SetDefaults_Probe(a.StartupProbe)
 				if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 				}
+				if a.StartupProbe.ProbeHandler.GRPC != nil {
+					if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.Lifecycle != nil {
 				if a.Lifecycle.PostStart != nil {
@@ -749,18 +875,36 @@ func SetObjectDefaults_ReplicationController(in *v1.ReplicationController) {
 				if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.LivenessProbe.ProbeHandler.GRPC != nil {
+					if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.ReadinessProbe != nil {
 				SetDefaults_Probe(a.ReadinessProbe)
 				if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+					if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.StartupProbe != nil {
 				SetDefaults_Probe(a.StartupProbe)
 				if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 				}
+				if a.StartupProbe.ProbeHandler.GRPC != nil {
+					if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.Lifecycle != nil {
 				if a.Lifecycle.PostStart != nil {
@@ -799,18 +943,36 @@ func SetObjectDefaults_ReplicationController(in *v1.ReplicationController) {
 				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+					if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.EphemeralContainerCommon.ReadinessProbe != nil {
 				SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 				}
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+					if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.EphemeralContainerCommon.StartupProbe != nil {
 				SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 					SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 				}
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+					if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+						var ptrVar1 string = ""
+						a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+					}
+				}
 			}
 			if a.EphemeralContainerCommon.Lifecycle != nil {
 				if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/apis/core/validation/validation.go

@@ -2725,6 +2725,7 @@ type commonHandler struct {
 	Exec      *core.ExecAction
 	HTTPGet   *core.HTTPGetAction
 	TCPSocket *core.TCPSocketAction
+	GRPC      *core.GRPCAction
 }
 
 func handlerFromProbe(ph *core.ProbeHandler) commonHandler {
@@ -2732,6 +2733,7 @@ func handlerFromProbe(ph *core.ProbeHandler) commonHandler {
 		Exec:      ph.Exec,
 		HTTPGet:   ph.HTTPGet,
 		TCPSocket: ph.TCPSocket,
+		GRPC:      ph.GRPC,
 	}
 }
 
@@ -2848,7 +2850,9 @@ func ValidatePortNumOrName(port intstr.IntOrString, fldPath *field.Path) field.E
 func validateTCPSocketAction(tcp *core.TCPSocketAction, fldPath *field.Path) field.ErrorList {
 	return ValidatePortNumOrName(tcp.Port, fldPath.Child("port"))
 }
-
+func validateGRPCAction(grpc *core.GRPCAction, fldPath *field.Path) field.ErrorList {
+	return ValidatePortNumOrName(intstr.FromInt(int(grpc.Port)), fldPath.Child("port"))
+}
 func validateHandler(handler commonHandler, fldPath *field.Path) field.ErrorList {
 	numHandlers := 0
 	allErrors := field.ErrorList{}
@@ -2876,6 +2880,14 @@ func validateHandler(handler commonHandler, fldPath *field.Path) field.ErrorList
 			allErrors = append(allErrors, validateTCPSocketAction(handler.TCPSocket, fldPath.Child("tcpSocket"))...)
 		}
 	}
+	if handler.GRPC != nil {
+		if numHandlers > 0 {
+			allErrors = append(allErrors, field.Forbidden(fldPath.Child("gRPC"), "may not specify more than 1 handler type"))
+		} else {
+			numHandlers++
+			allErrors = append(allErrors, validateGRPCAction(handler.GRPC, fldPath.Child("gRPC"))...)
+		}
+	}
 	if numHandlers == 0 {
 		allErrors = append(allErrors, field.Required(fldPath, "must specify a handler type"))
 	}

pkg/apis/core/zz_generated.deepcopy.go

@@ -1669,6 +1669,27 @@ func (in *GCEPersistentDiskVolumeSource) DeepCopy() *GCEPersistentDiskVolumeSour
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *GRPCAction) DeepCopyInto(out *GRPCAction) {
+	*out = *in
+	if in.Service != nil {
+		in, out := &in.Service, &out.Service
+		*out = new(string)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GRPCAction.
+func (in *GRPCAction) DeepCopy() *GRPCAction {
+	if in == nil {
+		return nil
+	}
+	out := new(GRPCAction)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *GitRepoVolumeSource) DeepCopyInto(out *GitRepoVolumeSource) {
 	*out = *in
@@ -4234,6 +4255,11 @@ func (in *ProbeHandler) DeepCopyInto(out *ProbeHandler) {
 		*out = new(TCPSocketAction)
 		**out = **in
 	}
+	if in.GRPC != nil {
+		in, out := &in.GRPC, &out.GRPC
+		*out = new(GRPCAction)
+		(*in).DeepCopyInto(*out)
+	}
 	return
 }
 

pkg/apis/extensions/v1beta1/zz_generated.defaults.go

@@ -131,18 +131,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta1.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -181,18 +199,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta1.DaemonSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -231,18 +267,36 @@ func SetObjectDefaults_DaemonSet(in *v1beta1.DaemonSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -352,18 +406,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -402,18 +474,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -452,18 +542,36 @@ func SetObjectDefaults_Deployment(in *v1beta1.Deployment) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
@@ -614,18 +722,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta1.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -664,18 +790,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta1.ReplicaSet) {
 			if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.ReadinessProbe)
 			if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.StartupProbe)
 			if a.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.Lifecycle != nil {
 			if a.Lifecycle.PostStart != nil {
@@ -714,18 +858,36 @@ func SetObjectDefaults_ReplicaSet(in *v1beta1.ReplicaSet) {
 			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.ReadinessProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
 			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.StartupProbe != nil {
 			v1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
 			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
 				v1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
 			}
+			if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
+				if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
+					var ptrVar1 string = ""
+					a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
+				}
+			}
 		}
 		if a.EphemeralContainerCommon.Lifecycle != nil {
 			if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {

pkg/features/kube_features.go

@@ -836,6 +836,13 @@ const (
 	//
 	// Allow users to recover from volume expansion failure
 	RecoverVolumeExpansionFailure featuregate.Feature = "RecoverVolumeExpansionFailure"
+
+	// owner: @yuzhiquan, @bowei, @PxyUp
+	// kep: http://kep.k8s.io/2727
+	// alpha: v1.23
+	//
+	// Enables GRPC probe method for {Liveness,Readiness,Startup}Probe.
+	GRPCContainerProbe featuregate.Feature = "GRPCContainerProbe"
 )
 
 func init() {
@@ -958,6 +965,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS
 	PodAndContainerStatsFromCRI:                    {Default: false, PreRelease: featuregate.Alpha},
 	HonorPVReclaimPolicy:                           {Default: false, PreRelease: featuregate.Alpha},
 	RecoverVolumeExpansionFailure:                  {Default: false, PreRelease: featuregate.Alpha},
+	GRPCContainerProbe:                             {Default: false, PreRelease: featuregate.Alpha},
 
 	// inherited features from generic apiserver, relisted here to get a conflict if it is changed
 	// unintentionally on either side:

pkg/kubelet/prober/prober.go

@@ -28,13 +28,16 @@ import (
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/client-go/tools/record"
+	kubefeatures "k8s.io/kubernetes/pkg/features"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/events"
 	"k8s.io/kubernetes/pkg/kubelet/prober/results"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
 	"k8s.io/kubernetes/pkg/probe"
 	execprobe "k8s.io/kubernetes/pkg/probe/exec"
+	grpcprobe "k8s.io/kubernetes/pkg/probe/grpc"
 	httpprobe "k8s.io/kubernetes/pkg/probe/http"
 	tcpprobe "k8s.io/kubernetes/pkg/probe/tcp"
 	"k8s.io/utils/exec"
@@ -54,6 +57,7 @@ type prober struct {
 	livenessHTTP  httpprobe.Prober
 	startupHTTP   httpprobe.Prober
 	tcp           tcpprobe.Prober
+	grpc          grpcprobe.Prober
 	runner        kubecontainer.CommandRunner
 
 	recorder record.EventRecorder
@@ -72,6 +76,7 @@ func newProber(
 		livenessHTTP:  httpprobe.New(followNonLocalRedirects),
 		startupHTTP:   httpprobe.New(followNonLocalRedirects),
 		tcp:           tcpprobe.New(),
+		grpc:          grpcprobe.New(),
 		runner:        runner,
 		recorder:      recorder,
 	}
@@ -170,7 +175,7 @@ func (pb *prober) runProbe(probeType probeType, p *v1.Probe, pod *v1.Pod, status
 			return probe.Unknown, "", err
 		}
 		path := p.HTTPGet.Path
-		klog.V(4).InfoS("HTTP-Probe Host", "scheme", scheme, "host", host, "port", port, "path", path)
+		klog.V(4).InfoS("HTTP-Probe", "scheme", scheme, "host", host, "port", port, "path", path, "timeout", timeout)
 		url := formatURL(scheme, host, port, path)
 		headers := buildHeader(p.HTTPGet.HTTPHeaders)
 		klog.V(4).InfoS("HTTP-Probe Headers", "headers", headers)
@@ -192,9 +197,17 @@ func (pb *prober) runProbe(probeType probeType, p *v1.Probe, pod *v1.Pod, status
 		if host == "" {
 			host = status.PodIP
 		}
-		klog.V(4).InfoS("TCP-Probe Host", "host", host, "port", port, "timeout", timeout)
+		klog.V(4).InfoS("TCP-Probe", "host", host, "port", port, "timeout", timeout)
 		return pb.tcp.Probe(host, port, timeout)
 	}
+
+	if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.GRPCContainerProbe) && p.GRPC != nil {
+		host := &(status.PodIP)
+		service := p.GRPC.Service
+		klog.V(4).InfoS("GRPC-Probe", "host", host, "service", service, "port", p.GRPC.Port, "timeout", timeout)
+		return pb.grpc.Probe(*host, *service, int(p.GRPC.Port), timeout)
+	}
+
 	klog.InfoS("Failed to find probe builder for container", "containerName", container.Name)
 	return probe.Unknown, "", fmt.Errorf("missing probe handler for %s:%s", format.Pod(pod), container.Name)
 }

pkg/probe/grpc/grpc.go

@@ -0,0 +1,111 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package grpc
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	grpchealth "google.golang.org/grpc/health/grpc_health_v1"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+	"k8s.io/component-base/version"
+	"k8s.io/klog/v2"
+	"k8s.io/kubernetes/pkg/probe"
+)
+
+// Prober is an interface that defines the Probe function for doing GRPC readiness/liveness/startup checks.
+type Prober interface {
+	Probe(host, service string, port int, timeout time.Duration, opts ...grpc.DialOption) (probe.Result, string, error)
+}
+
+type grpcProber struct {
+}
+
+// New Prober for execute grpc probe
+func New() Prober {
+	return grpcProber{}
+}
+
+// Probe executes a grpc call to check the liveness/readiness/startup of container.
+// Returns the Result status, command output, and errors if any.
+// Only return non-nil error when service is unavailable and/or not implementing the interface,
+// otherwise result status is failed,BUT err is nil
+func (p grpcProber) Probe(host, service string, port int, timeout time.Duration, opts ...grpc.DialOption) (probe.Result, string, error) {
+	v := version.Get()
+
+	md := metadata.New(map[string]string{
+		"User-Agent": fmt.Sprintf("kube-probe/%s.%s", v.Major, v.Minor),
+	})
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+
+	defer cancel()
+
+	addr := net.JoinHostPort(host, fmt.Sprintf("%d", port))
+	conn, err := grpc.DialContext(ctx, addr, opts...)
+
+	if err != nil {
+		if err == context.DeadlineExceeded {
+			klog.V(4).ErrorS(err, "failed to connect grpc service due to timeout", "addr", addr, "service", service, "timeout", timeout)
+			return probe.Failure, fmt.Sprintf("GRPC probe failed to dial: %s", err), nil
+		} else {
+			klog.V(4).ErrorS(err, "failed to connect grpc service", "service", addr)
+			return probe.Failure, "", fmt.Errorf("GRPC probe failed to dial: %w", err)
+		}
+	}
+
+	defer func() {
+		_ = conn.Close()
+	}()
+
+	client := grpchealth.NewHealthClient(conn)
+
+	resp, err := client.Check(metadata.NewOutgoingContext(ctx, md), &grpchealth.HealthCheckRequest{
+		Service: service,
+	})
+
+	if err != nil {
+		state, ok := status.FromError(err)
+		if ok {
+			switch state.Code() {
+			case codes.Unimplemented:
+				klog.V(4).ErrorS(err, "server does not implement the grpc health protocol (grpc.health.v1.Health)", "addr", addr, "service", service)
+				return probe.Failure, "", fmt.Errorf("server does not implement the grpc health protocol: %w", err)
+			case codes.DeadlineExceeded:
+				klog.V(4).ErrorS(err, "rpc request not finished within timeout", "addr", addr, "service", service, "timeout", timeout)
+				return probe.Failure, fmt.Sprintf("GRPC probe failed with DeadlineExceeded"), nil
+			default:
+				klog.V(4).ErrorS(err, "rpc probe failed")
+			}
+		} else {
+			klog.V(4).ErrorS(err, "health rpc probe failed")
+		}
+
+		return probe.Failure, "", fmt.Errorf("health rpc probe failed: %w", err)
+	}
+
+	if resp.Status != grpchealth.HealthCheckResponse_SERVING {
+		return probe.Failure, fmt.Sprintf("GRPC probe failed with status: %s", resp.Status.String()), nil
+	}
+
+	return probe.Success, fmt.Sprintf("GRPC probe success"), nil
+}

pkg/probe/grpc/grpc_test.go

@@ -0,0 +1,186 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package grpc
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+	grpchealth "google.golang.org/grpc/health/grpc_health_v1"
+
+	"k8s.io/kubernetes/pkg/probe"
+)
+
+func TestNew(t *testing.T) {
+	t.Run("Should: implement Probe interface", func(t *testing.T) {
+		s := New()
+		assert.Implements(t, (*Prober)(nil), s)
+	})
+}
+
+type successServerMock struct {
+}
+
+func (s successServerMock) Check(context.Context, *grpchealth.HealthCheckRequest) (*grpchealth.HealthCheckResponse, error) {
+	return &grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_SERVING,
+	}, nil
+}
+
+func (s successServerMock) Watch(_ *grpchealth.HealthCheckRequest, stream grpchealth.Health_WatchServer) error {
+	return stream.Send(&grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_SERVING,
+	})
+}
+
+type errorTimeoutServerMock struct {
+}
+
+func (e errorTimeoutServerMock) Check(context.Context, *grpchealth.HealthCheckRequest) (*grpchealth.HealthCheckResponse, error) {
+	time.Sleep(time.Second * 4)
+	return &grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_SERVING,
+	}, nil
+}
+
+func (e errorTimeoutServerMock) Watch(_ *grpchealth.HealthCheckRequest, stream grpchealth.Health_WatchServer) error {
+	time.Sleep(time.Second * 4)
+	return stream.Send(&grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_SERVING,
+	})
+}
+
+type errorNotServeServerMock struct {
+}
+
+func (e errorNotServeServerMock) Check(context.Context, *grpchealth.HealthCheckRequest) (*grpchealth.HealthCheckResponse, error) {
+	return &grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_NOT_SERVING,
+	}, nil
+}
+
+func (e errorNotServeServerMock) Watch(_ *grpchealth.HealthCheckRequest, stream grpchealth.Health_WatchServer) error {
+	return stream.Send(&grpchealth.HealthCheckResponse{
+		Status: grpchealth.HealthCheckResponse_NOT_SERVING,
+	})
+}
+
+func TestGrpcProber_Probe(t *testing.T) {
+	t.Run("Should: failed but return nil error because cant find host", func(t *testing.T) {
+		s := New()
+		p, o, err := s.Probe("", "", 32, time.Second, grpc.WithInsecure(), grpc.WithBlock())
+		assert.Equal(t, probe.Failure, p)
+		assert.Equal(t, nil, err)
+		assert.Equal(t, "GRPC probe failed to dial: context deadline exceeded", o)
+	})
+	t.Run("Should: return nil error because connection closed", func(t *testing.T) {
+		s := New()
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			fmt.Fprint(w, "res")
+		}))
+		u := strings.Split(server.URL, ":")
+		assert.Equal(t, 3, len(u))
+
+		port, err := strconv.Atoi(u[2])
+		assert.Equal(t, nil, err)
+
+		// take some time to wait server boot
+		time.Sleep(2 * time.Second)
+		p, _, err := s.Probe("127.0.0.1", "", port, time.Second, grpc.WithInsecure())
+		assert.Equal(t, probe.Failure, p)
+		assert.NotEqual(t, nil, err)
+	})
+	t.Run("Should: return nil error because server response not served", func(t *testing.T) {
+		s := New()
+		lis, _ := net.Listen("tcp", ":0")
+		port := lis.Addr().(*net.TCPAddr).Port
+		grpcServer := grpc.NewServer()
+		defer grpcServer.Stop()
+		grpchealth.RegisterHealthServer(grpcServer, &errorNotServeServerMock{})
+		go func() {
+			_ = grpcServer.Serve(lis)
+		}()
+		// take some time to wait server boot
+		time.Sleep(2 * time.Second)
+		p, o, err := s.Probe("0.0.0.0", "", port, time.Second, grpc.WithInsecure())
+		assert.Equal(t, probe.Failure, p)
+		assert.Equal(t, nil, err)
+		assert.Equal(t, "GRPC probe failed with status: NOT_SERVING", o)
+	})
+	t.Run("Should: return nil-error because server not response in time", func(t *testing.T) {
+		s := New()
+		lis, _ := net.Listen("tcp", ":0")
+		port := lis.Addr().(*net.TCPAddr).Port
+
+		grpcServer := grpc.NewServer()
+		defer grpcServer.Stop()
+		grpchealth.RegisterHealthServer(grpcServer, &errorTimeoutServerMock{})
+		go func() {
+			_ = grpcServer.Serve(lis)
+		}()
+		// take some time to wait server boot
+		time.Sleep(2 * time.Second)
+		p, o, err := s.Probe("0.0.0.0", "", port, time.Second*2, grpc.WithInsecure())
+		assert.Equal(t, probe.Failure, p)
+		assert.Equal(t, nil, err)
+		assert.Equal(t, "GRPC probe failed with DeadlineExceeded", o)
+
+	})
+	t.Run("Should: not return error because check was success", func(t *testing.T) {
+		s := New()
+		lis, _ := net.Listen("tcp", ":0")
+		port := lis.Addr().(*net.TCPAddr).Port
+
+		grpcServer := grpc.NewServer()
+		defer grpcServer.Stop()
+		grpchealth.RegisterHealthServer(grpcServer, &successServerMock{})
+		go func() {
+			_ = grpcServer.Serve(lis)
+		}()
+		// take some time to wait server boot
+		time.Sleep(2 * time.Second)
+		p, _, err := s.Probe("0.0.0.0", "", port, time.Second*2, grpc.WithInsecure())
+		assert.Equal(t, probe.Success, p)
+		assert.Equal(t, nil, err)
+	})
+	t.Run("Should: not return error because check was success, when listen port is 0", func(t *testing.T) {
+		s := New()
+		lis, _ := net.Listen("tcp", ":0")
+		port := lis.Addr().(*net.TCPAddr).Port
+
+		grpcServer := grpc.NewServer()
+		defer grpcServer.Stop()
+		grpchealth.RegisterHealthServer(grpcServer, &successServerMock{})
+		go func() {
+			_ = grpcServer.Serve(lis)
+		}()
+		// take some time to wait server boot
+		time.Sleep(2 * time.Second)
+		p, _, err := s.Probe("0.0.0.0", "", port, time.Second*2, grpc.WithInsecure())
+		assert.Equal(t, probe.Success, p)
+		assert.Equal(t, nil, err)
+	})
+}

staging/src/k8s.io/api/core/v1/generated.proto

@@ -1646,6 +1646,19 @@ message GCEPersistentDiskVolumeSource {
   optional bool readOnly = 4;
 }
 
+message GRPCAction {
+  // Port number of the gRPC service. Number must be in the range 1 to 65535.
+  optional int32 port = 1;
+
+  // Service is the name of the service to place in the gRPC HealthCheckRequest
+  // (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
+  //
+  // If this is not specified, the default behavior is defined by gRPC.
+  // +optional
+  // +default=""
+  optional string service = 2;
+}
+
 // Represents a volume that is populated with the contents of a git repository.
 // Git repo volumes do not support ownership management.
 // Git repo volumes support SELinux relabeling.
@@ -4005,6 +4018,12 @@ message ProbeHandler {
   // TCPSocket specifies an action involving a TCP port.
   // +optional
   optional TCPSocketAction tcpSocket = 3;
+
+  // GRPC specifies an action involving a GRPC port.
+  // This is an alpha field and requires enabling GRPCContainerProbe feature gate.
+  // +featureGate=GRPCContainerProbe
+  // +optional
+  optional GRPCAction grpc = 4;
 }
 
 // Represents a projected volume source

staging/src/k8s.io/api/core/v1/types.go

@@ -2156,6 +2156,19 @@ type TCPSocketAction struct {
 	Host string `json:"host,omitempty" protobuf:"bytes,2,opt,name=host"`
 }
 
+type GRPCAction struct {
+	// Port number of the gRPC service. Number must be in the range 1 to 65535.
+	Port int32 `json:"port" protobuf:"bytes,1,opt,name=port"`
+
+	// Service is the name of the service to place in the gRPC HealthCheckRequest
+	// (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
+	//
+	// If this is not specified, the default behavior is defined by gRPC.
+	// +optional
+	// +default=""
+	Service *string `json:"service" protobuf:"bytes,2,opt,name=service"`
+}
+
 // ExecAction describes a "run in container" action.
 type ExecAction struct {
 	// Command is the command line to execute inside the container, the working directory for the
@@ -2450,6 +2463,12 @@ type ProbeHandler struct {
 	// TCPSocket specifies an action involving a TCP port.
 	// +optional
 	TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty" protobuf:"bytes,3,opt,name=tcpSocket"`
+
+	// GRPC specifies an action involving a GRPC port.
+	// This is an alpha field and requires enabling GRPCContainerProbe feature gate.
+	// +featureGate=GRPCContainerProbe
+	// +optional
+	GRPC *GRPCAction `json:"gRPC,omitempty" protobuf:"bytes,4,opt,name=grpc"`
 }
 
 // LifecycleHandler defines a specific action that should be taken in a lifecycle

staging/src/k8s.io/api/core/v1/types_swagger_doc_generated.go

@@ -749,6 +749,15 @@ func (GCEPersistentDiskVolumeSource) SwaggerDoc() map[string]string {
 	return map_GCEPersistentDiskVolumeSource
 }
 
+var map_GRPCAction = map[string]string{
+	"port":    "Port number of the gRPC service. Number must be in the range 1 to 65535.",
+	"service": "Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
+}
+
+func (GRPCAction) SwaggerDoc() map[string]string {
+	return map_GRPCAction
+}
+
 var map_GitRepoVolumeSource = map[string]string{
 	"":           "Represents a volume that is populated with the contents of a git repository. Git repo volumes do not support ownership management. Git repo volumes support SELinux relabeling.\n\nDEPRECATED: GitRepo is deprecated. To provision a container with a git repo, mount an EmptyDir into an InitContainer that clones the repo using git, then mount the EmptyDir into the Pod's container.",
 	"repository": "Repository URL",
@@ -1799,6 +1808,7 @@ var map_ProbeHandler = map[string]string{
 	"exec":      "Exec specifies the action to take.",
 	"httpGet":   "HTTPGet specifies the http request to perform.",
 	"tcpSocket": "TCPSocket specifies an action involving a TCP port.",
+	"gRPC":      "GRPC specifies an action involving a GRPC port. This is an alpha field and requires enabling GRPCContainerProbe feature gate.",
 }
 
 func (ProbeHandler) SwaggerDoc() map[string]string {

staging/src/k8s.io/api/core/v1/zz_generated.deepcopy.go

@@ -1669,6 +1669,27 @@ func (in *GCEPersistentDiskVolumeSource) DeepCopy() *GCEPersistentDiskVolumeSour
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *GRPCAction) DeepCopyInto(out *GRPCAction) {
+	*out = *in
+	if in.Service != nil {
+		in, out := &in.Service, &out.Service
+		*out = new(string)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GRPCAction.
+func (in *GRPCAction) DeepCopy() *GRPCAction {
+	if in == nil {
+		return nil
+	}
+	out := new(GRPCAction)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *GitRepoVolumeSource) DeepCopyInto(out *GitRepoVolumeSource) {
 	*out = *in
@@ -4232,6 +4253,11 @@ func (in *ProbeHandler) DeepCopyInto(out *ProbeHandler) {
 		*out = new(TCPSocketAction)
 		**out = **in
 	}
+	if in.GRPC != nil {
+		in, out := &in.GRPC, &out.GRPC
+		*out = new(GRPCAction)
+		(*in).DeepCopyInto(*out)
+	}
 	return
 }
 

staging/src/k8s.io/client-go/applyconfigurations/core/v1/grpcaction.go

@@ -0,0 +1,48 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v1
+
+// GRPCActionApplyConfiguration represents an declarative configuration of the GRPCAction type for use
+// with apply.
+type GRPCActionApplyConfiguration struct {
+	Port    *int32  `json:"port,omitempty"`
+	Service *string `json:"service,omitempty"`
+}
+
+// GRPCActionApplyConfiguration constructs an declarative configuration of the GRPCAction type for use with
+// apply.
+func GRPCAction() *GRPCActionApplyConfiguration {
+	return &GRPCActionApplyConfiguration{}
+}
+
+// WithPort sets the Port field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Port field is set to the value of the last call.
+func (b *GRPCActionApplyConfiguration) WithPort(value int32) *GRPCActionApplyConfiguration {
+	b.Port = &value
+	return b
+}
+
+// WithService sets the Service field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Service field is set to the value of the last call.
+func (b *GRPCActionApplyConfiguration) WithService(value string) *GRPCActionApplyConfiguration {
+	b.Service = &value
+	return b
+}

staging/src/k8s.io/client-go/applyconfigurations/core/v1/probe.go

@@ -60,6 +60,14 @@ func (b *ProbeApplyConfiguration) WithTCPSocket(value *TCPSocketActionApplyConfi
 	return b
 }
 
+// WithGRPC sets the GRPC field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the GRPC field is set to the value of the last call.
+func (b *ProbeApplyConfiguration) WithGRPC(value *GRPCActionApplyConfiguration) *ProbeApplyConfiguration {
+	b.GRPC = value
+	return b
+}
+
 // WithInitialDelaySeconds sets the InitialDelaySeconds field in the declarative configuration to the given value
 // and returns the receiver, so that objects can be built by chaining "With" function invocations.
 // If called multiple times, the InitialDelaySeconds field is set to the value of the last call.

staging/src/k8s.io/client-go/applyconfigurations/core/v1/probehandler.go

@@ -24,6 +24,7 @@ type ProbeHandlerApplyConfiguration struct {
 	Exec      *ExecActionApplyConfiguration      `json:"exec,omitempty"`
 	HTTPGet   *HTTPGetActionApplyConfiguration   `json:"httpGet,omitempty"`
 	TCPSocket *TCPSocketActionApplyConfiguration `json:"tcpSocket,omitempty"`
+	GRPC      *GRPCActionApplyConfiguration      `json:"gRPC,omitempty"`
 }
 
 // ProbeHandlerApplyConfiguration constructs an declarative configuration of the ProbeHandler type for use with
@@ -55,3 +56,11 @@ func (b *ProbeHandlerApplyConfiguration) WithTCPSocket(value *TCPSocketActionApp
 	b.TCPSocket = value
 	return b
 }
+
+// WithGRPC sets the GRPC field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the GRPC field is set to the value of the last call.
+func (b *ProbeHandlerApplyConfiguration) WithGRPC(value *GRPCActionApplyConfiguration) *ProbeHandlerApplyConfiguration {
+	b.GRPC = value
+	return b
+}

staging/src/k8s.io/client-go/applyconfigurations/internal/internal.go

@@ -4478,6 +4478,17 @@ var schemaYAML = typed.YAMLObject(`types:
     - name: readOnly
       type:
         scalar: boolean
+- name: io.k8s.api.core.v1.GRPCAction
+  map:
+    fields:
+    - name: port
+      type:
+        scalar: numeric
+      default: 0
+    - name: service
+      type:
+        scalar: string
+      default: ""
 - name: io.k8s.api.core.v1.GitRepoVolumeSource
   map:
     fields:
@@ -5937,6 +5948,9 @@ var schemaYAML = typed.YAMLObject(`types:
     - name: failureThreshold
       type:
         scalar: numeric
+    - name: gRPC
+      type:
+        namedType: io.k8s.api.core.v1.GRPCAction
     - name: httpGet
       type:
         namedType: io.k8s.api.core.v1.HTTPGetAction

staging/src/k8s.io/client-go/applyconfigurations/utils.go

@@ -601,6 +601,8 @@ func ForKind(kind schema.GroupVersionKind) interface{} {
 		return &applyconfigurationscorev1.GlusterfsPersistentVolumeSourceApplyConfiguration{}
 	case corev1.SchemeGroupVersion.WithKind("GlusterfsVolumeSource"):
 		return &applyconfigurationscorev1.GlusterfsVolumeSourceApplyConfiguration{}
+	case corev1.SchemeGroupVersion.WithKind("GRPCAction"):
+		return &applyconfigurationscorev1.GRPCActionApplyConfiguration{}
 	case corev1.SchemeGroupVersion.WithKind("HostAlias"):
 		return &applyconfigurationscorev1.HostAliasApplyConfiguration{}
 	case corev1.SchemeGroupVersion.WithKind("HostPathVolumeSource"):

staging/src/k8s.io/kubectl/pkg/describe/describe.go

@@ -1943,6 +1943,9 @@ func DescribeProbe(probe *corev1.Probe) string {
 		return fmt.Sprintf("http-get %s %s", url.String(), attrs)
 	case probe.TCPSocket != nil:
 		return fmt.Sprintf("tcp-socket %s:%s %s", probe.TCPSocket.Host, probe.TCPSocket.Port.String(), attrs)
+
+	case probe.GRPC != nil:
+		return fmt.Sprintf("grpc <pod>:%d %s %s", probe.GRPC.Port, *(probe.GRPC.Service), attrs)
 	}
 	return fmt.Sprintf("unknown %s", attrs)
 }

test/e2e/common/node/container_probe.go

@@ -19,6 +19,7 @@ package node
 import (
 	"context"
 	"fmt"
+	"net"
 	"net/url"
 	"time"
 
@@ -35,10 +36,10 @@ import (
 	e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
 	e2eskipper "k8s.io/kubernetes/test/e2e/framework/skipper"
 	testutils "k8s.io/kubernetes/test/utils"
+	imageutils "k8s.io/kubernetes/test/utils/image"
 
 	"github.com/onsi/ginkgo"
 	"github.com/onsi/gomega"
-	imageutils "k8s.io/kubernetes/test/utils/image"
 )
 
 const (
@@ -512,6 +513,52 @@ var _ = SIGDescribe("Probing container", func() {
 		// 10s delay + 10s period + 5s grace period = 25s < 30s << pod-level timeout 500
 		RunLivenessTest(f, pod, 1, time.Second*30)
 	})
+
+	/*
+		Release: v1.23
+		Testname: Pod liveness probe, using grpc call, success
+		Description: A Pod is created with liveness probe on grpc service. Liveness probe on this endpoint will not fail. When liveness probe does not fail then the restart count MUST remain zero.
+	*/
+	ginkgo.It("should *not* be restarted with a GRPC liveness probe [NodeAlphaFeature:GRPCContainerProbe][Feature:GRPCContainerProbe]", func() {
+		e2eskipper.SkipUnlessFeatureGateEnabled(kubefeatures.GRPCContainerProbe)
+
+		livenessProbe := &v1.Probe{
+			ProbeHandler: v1.ProbeHandler{
+				GRPC: &v1.GRPCAction{
+					Port:    2379,
+					Service: nil,
+				},
+			},
+			InitialDelaySeconds: probeTestInitialDelaySeconds,
+			FailureThreshold:    1,
+		}
+
+		pod := gRPCServerPodSpec(nil, livenessProbe, "etcd")
+		RunLivenessTest(f, pod, 0, defaultObservationTimeout)
+	})
+
+	/*
+			Release: v1.23
+			Testname: Pod liveness probe, using grpc call, failure
+			Description: A Pod is created with liveness probe on grpc service. Liveness probe on this endpoint should fail because of wrong probe port.
+		                 When liveness probe does  fail then the restart count should +1.
+	*/
+	ginkgo.It("should be restarted with a GRPC liveness probe [NodeAlphaFeature:GRPCContainerProbe][Feature:GRPCContainerProbe]", func() {
+		e2eskipper.SkipUnlessFeatureGateEnabled(kubefeatures.GRPCContainerProbe)
+		service := "etcd_health"
+		livenessProbe := &v1.Probe{
+			ProbeHandler: v1.ProbeHandler{
+				GRPC: &v1.GRPCAction{
+					Port:    2379 + 1, // this port is wrong
+					Service: &service,
+				},
+			},
+			InitialDelaySeconds: probeTestInitialDelaySeconds * 4,
+			FailureThreshold:    1,
+		}
+		pod := gRPCServerPodSpec(nil, livenessProbe, "etcd")
+		RunLivenessTest(f, pod, 1, defaultObservationTimeout)
+	})
 })
 
 // GetContainerStartedTime returns the time when the given container started and error if any
@@ -758,3 +805,31 @@ func runReadinessFailTest(f *framework.Framework, pod *v1.Pod, notReadyUntil tim
 			ns, pod.Name, time.Since(start))
 	}
 }
+
+func gRPCServerPodSpec(readinessProbe, livenessProbe *v1.Probe, containerName string) *v1.Pod {
+	etcdLocalhostAddress := "127.0.0.1"
+	if framework.TestContext.ClusterIsIPv6() {
+		etcdLocalhostAddress = "::1"
+	}
+	etcdURL := fmt.Sprintf("http://%s", net.JoinHostPort(etcdLocalhostAddress, "2379"))
+	return &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{Name: "test-grpc-" + string(uuid.NewUUID())},
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:  containerName,
+					Image: imageutils.GetE2EImage(imageutils.Etcd),
+					Command: []string{
+						"/usr/local/bin/etcd",
+						"--listen-client-urls",
+						etcdURL,
+						"--advertise-client-urls",
+						etcdURL,
+					},
+					LivenessProbe:  livenessProbe,
+					ReadinessProbe: readinessProbe,
+				},
+			},
+		},
+	}
+}

test/e2e_node/image_list.go

@@ -63,6 +63,7 @@ var NodePrePullImageList = sets.NewString(
 	imageutils.GetE2EImage(imageutils.NodePerfNpbEp),
 	imageutils.GetE2EImage(imageutils.NodePerfNpbIs),
 	imageutils.GetE2EImage(imageutils.NodePerfTfWideDeep),
+	imageutils.GetE2EImage(imageutils.Etcd),
 )
 
 // updateImageAllowList updates the framework.ImagePrePullList with