From 679efd5601b7a2d9cdb38c05452440d6f13875dc Mon Sep 17 00:00:00 2001 From: Modular Magician Date: Fri, 14 Oct 2022 23:01:37 +0000 Subject: [PATCH] Adds `liveness_probe` field to `google_cloud_run_service` resource for beta (#6677) * add liveness probe * fix comment and tests * Update mmv1/products/cloudrun/api.yaml Co-authored-by: Stephen Lewis (Burrows) * Update mmv1/products/cloudrun/api.yaml Co-authored-by: Stephen Lewis (Burrows) * allow_empty_object: true Co-authored-by: Stephen Lewis (Burrows) Signed-off-by: Modular Magician --- .changelog/6677.txt | 3 + google-beta/resource_cloud_run_service.go | 396 +++++++++++++++++- ...source_cloud_run_service_generated_test.go | 5 + .../resource_cloud_run_service_test.go | 29 +- .../docs/r/cloud_run_service.html.markdown | 65 +++ 5 files changed, 474 insertions(+), 24 deletions(-) create mode 100644 .changelog/6677.txt diff --git a/.changelog/6677.txt b/.changelog/6677.txt new file mode 100644 index 0000000000..7b2a10b365 --- /dev/null +++ b/.changelog/6677.txt @@ -0,0 +1,3 @@ +```release-note:enhancement +cloudrun: added field `liveness_probe` to resource `google_cloud_run_service` (beta) +``` diff --git a/google-beta/resource_cloud_run_service.go b/google-beta/resource_cloud_run_service.go index 7e46620154..14a5aefba1 100644 --- a/google-beta/resource_cloud_run_service.go +++ b/google-beta/resource_cloud_run_service.go @@ -289,6 +289,83 @@ https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names`, }, }, }, + "liveness_probe": { + Type: schema.TypeList, + Optional: true, + Description: `Periodic probe of container liveness. Container will be restarted if the probe fails. More info: +https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "failure_threshold": { + Type: schema.TypeInt, + Optional: true, + Description: `Minimum consecutive failures for the probe to be considered failed after +having succeeded. Defaults to 3. Minimum value is 1.`, + Default: 3, + }, + "http_get": { + Type: schema.TypeList, + Optional: true, + Description: `HttpGet specifies the http request to perform.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "http_headers": { + Type: schema.TypeList, + Optional: true, + Description: `Custom headers to set in the request. HTTP allows repeated headers.`, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + Description: `The header field name.`, + }, + "value": { + Type: schema.TypeString, + Optional: true, + Description: `The header field value.`, + Default: "", + }, + }, + }, + }, + "path": { + Type: schema.TypeString, + Optional: true, + Description: `Path to access on the HTTP server. If set, it should not be empty string.`, + Default: "/", + }, + }, + }, + }, + "initial_delay_seconds": { + Type: schema.TypeInt, + Optional: true, + Description: `Number of seconds after the container has started before the probe is +initiated. +Defaults to 0 seconds. Minimum value is 0. Maximum value is 3600.`, + Default: 0, + }, + "period_seconds": { + Type: schema.TypeInt, + Optional: true, + Description: `How often (in seconds) to perform the probe. +Default to 10 seconds. Minimum value is 1. Maximum value is 3600.`, + Default: 10, + }, + "timeout_seconds": { + Type: schema.TypeInt, + Optional: true, + Description: `Number of seconds after which the probe times out. +Defaults to 1 second. Minimum value is 1. Maximum value is 3600. +Must be smaller than period_seconds.`, + Default: 1, + }, + }, + }, + }, "ports": { Type: schema.TypeList, Computed: true, @@ -355,7 +432,9 @@ https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachi Optional: true, Description: `Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it -succeeds. Container will not be added to service endpoints if the probe fails.`, +succeeds. Container will not be added to service endpoints if the probe fails. +More info: +https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes`, MaxItems: 1, Elem: &schema.Resource{ Schema: map[string]*schema.Schema{ @@ -1456,16 +1535,17 @@ func flattenCloudRunServiceSpecTemplateSpecContainers(v interface{}, d *schema.R continue } transformed = append(transformed, map[string]interface{}{ - "working_dir": flattenCloudRunServiceSpecTemplateSpecContainersWorkingDir(original["workingDir"], d, config), - "args": flattenCloudRunServiceSpecTemplateSpecContainersArgs(original["args"], d, config), - "env_from": flattenCloudRunServiceSpecTemplateSpecContainersEnvFrom(original["envFrom"], d, config), - "image": flattenCloudRunServiceSpecTemplateSpecContainersImage(original["image"], d, config), - "command": flattenCloudRunServiceSpecTemplateSpecContainersCommand(original["command"], d, config), - "env": flattenCloudRunServiceSpecTemplateSpecContainersEnv(original["env"], d, config), - "ports": flattenCloudRunServiceSpecTemplateSpecContainersPorts(original["ports"], d, config), - "resources": flattenCloudRunServiceSpecTemplateSpecContainersResources(original["resources"], d, config), - "volume_mounts": flattenCloudRunServiceSpecTemplateSpecContainersVolumeMounts(original["volumeMounts"], d, config), - "startup_probe": flattenCloudRunServiceSpecTemplateSpecContainersStartupProbe(original["startupProbe"], d, config), + "working_dir": flattenCloudRunServiceSpecTemplateSpecContainersWorkingDir(original["workingDir"], d, config), + "args": flattenCloudRunServiceSpecTemplateSpecContainersArgs(original["args"], d, config), + "env_from": flattenCloudRunServiceSpecTemplateSpecContainersEnvFrom(original["envFrom"], d, config), + "image": flattenCloudRunServiceSpecTemplateSpecContainersImage(original["image"], d, config), + "command": flattenCloudRunServiceSpecTemplateSpecContainersCommand(original["command"], d, config), + "env": flattenCloudRunServiceSpecTemplateSpecContainersEnv(original["env"], d, config), + "ports": flattenCloudRunServiceSpecTemplateSpecContainersPorts(original["ports"], d, config), + "resources": flattenCloudRunServiceSpecTemplateSpecContainersResources(original["resources"], d, config), + "volume_mounts": flattenCloudRunServiceSpecTemplateSpecContainersVolumeMounts(original["volumeMounts"], d, config), + "startup_probe": flattenCloudRunServiceSpecTemplateSpecContainersStartupProbe(original["startupProbe"], d, config), + "liveness_probe": flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbe(original["livenessProbe"], d, config), }) } return transformed @@ -1837,9 +1917,6 @@ func flattenCloudRunServiceSpecTemplateSpecContainersStartupProbeTcpSocket(v int return nil } original := v.(map[string]interface{}) - if len(original) == 0 { - return nil - } transformed := make(map[string]interface{}) transformed["port"] = flattenCloudRunServiceSpecTemplateSpecContainersStartupProbeTcpSocketPort(original["port"], d, config) @@ -1867,9 +1944,6 @@ func flattenCloudRunServiceSpecTemplateSpecContainersStartupProbeHttpGet(v inter return nil } original := v.(map[string]interface{}) - if len(original) == 0 { - return nil - } transformed := make(map[string]interface{}) transformed["path"] = flattenCloudRunServiceSpecTemplateSpecContainersStartupProbeHttpGetPath(original["path"], d, config) @@ -1908,6 +1982,138 @@ func flattenCloudRunServiceSpecTemplateSpecContainersStartupProbeHttpGetHttpHead return v } +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbe(v interface{}, d *schema.ResourceData, config *Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["initial_delay_seconds"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeInitialDelaySeconds(original["initialDelaySeconds"], d, config) + transformed["timeout_seconds"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeTimeoutSeconds(original["timeoutSeconds"], d, config) + transformed["period_seconds"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbePeriodSeconds(original["periodSeconds"], d, config) + transformed["failure_threshold"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeFailureThreshold(original["failureThreshold"], d, config) + transformed["http_get"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGet(original["httpGet"], d, config) + return []interface{}{transformed} +} +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeInitialDelaySeconds(v interface{}, d *schema.ResourceData, config *Config) interface{} { + // Handles the string fixed64 format + if strVal, ok := v.(string); ok { + if intVal, err := stringToFixed64(strVal); err == nil { + return intVal + } + } + + // number values are represented as float64 + if floatVal, ok := v.(float64); ok { + intVal := int(floatVal) + return intVal + } + + return v // let terraform core handle it otherwise +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeTimeoutSeconds(v interface{}, d *schema.ResourceData, config *Config) interface{} { + // Handles the string fixed64 format + if strVal, ok := v.(string); ok { + if intVal, err := stringToFixed64(strVal); err == nil { + return intVal + } + } + + // number values are represented as float64 + if floatVal, ok := v.(float64); ok { + intVal := int(floatVal) + return intVal + } + + return v // let terraform core handle it otherwise +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbePeriodSeconds(v interface{}, d *schema.ResourceData, config *Config) interface{} { + // Handles the string fixed64 format + if strVal, ok := v.(string); ok { + if intVal, err := stringToFixed64(strVal); err == nil { + return intVal + } + } + + // number values are represented as float64 + if floatVal, ok := v.(float64); ok { + intVal := int(floatVal) + return intVal + } + + return v // let terraform core handle it otherwise +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeFailureThreshold(v interface{}, d *schema.ResourceData, config *Config) interface{} { + // Handles the string fixed64 format + if strVal, ok := v.(string); ok { + if intVal, err := stringToFixed64(strVal); err == nil { + return intVal + } + } + + // number values are represented as float64 + if floatVal, ok := v.(float64); ok { + intVal := int(floatVal) + return intVal + } + + return v // let terraform core handle it otherwise +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGet(v interface{}, d *schema.ResourceData, config *Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + transformed := make(map[string]interface{}) + transformed["path"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetPath(original["path"], d, config) + transformed["http_headers"] = + flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeaders(original["httpHeaders"], d, config) + return []interface{}{transformed} +} +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetPath(v interface{}, d *schema.ResourceData, config *Config) interface{} { + return v +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeaders(v interface{}, d *schema.ResourceData, config *Config) interface{} { + if v == nil { + return v + } + l := v.([]interface{}) + transformed := make([]interface{}, 0, len(l)) + for _, raw := range l { + original := raw.(map[string]interface{}) + if len(original) < 1 { + // Do not include empty json objects coming back from the api + continue + } + transformed = append(transformed, map[string]interface{}{ + "name": flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersName(original["name"], d, config), + "value": flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersValue(original["value"], d, config), + }) + } + return transformed +} +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersName(v interface{}, d *schema.ResourceData, config *Config) interface{} { + return v +} + +func flattenCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersValue(v interface{}, d *schema.ResourceData, config *Config) interface{} { + return v +} + func flattenCloudRunServiceSpecTemplateSpecContainerConcurrency(v interface{}, d *schema.ResourceData, config *Config) interface{} { // Handles the string fixed64 format if strVal, ok := v.(string); ok { @@ -2582,6 +2788,13 @@ func expandCloudRunServiceSpecTemplateSpecContainers(v interface{}, d TerraformR transformed["startupProbe"] = transformedStartupProbe } + transformedLivenessProbe, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbe(original["liveness_probe"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedLivenessProbe); val.IsValid() && !isEmptyValue(val) { + transformed["livenessProbe"] = transformedLivenessProbe + } + req = append(req, transformed) } return req, nil @@ -3052,9 +3265,14 @@ func expandCloudRunServiceSpecTemplateSpecContainersStartupProbeFailureThreshold func expandCloudRunServiceSpecTemplateSpecContainersStartupProbeTcpSocket(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { l := v.([]interface{}) - if len(l) == 0 || l[0] == nil { + if len(l) == 0 { return nil, nil } + + if l[0] == nil { + transformed := make(map[string]interface{}) + return transformed, nil + } raw := l[0] original := raw.(map[string]interface{}) transformed := make(map[string]interface{}) @@ -3075,9 +3293,14 @@ func expandCloudRunServiceSpecTemplateSpecContainersStartupProbeTcpSocketPort(v func expandCloudRunServiceSpecTemplateSpecContainersStartupProbeHttpGet(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { l := v.([]interface{}) - if len(l) == 0 || l[0] == nil { + if len(l) == 0 { return nil, nil } + + if l[0] == nil { + transformed := make(map[string]interface{}) + return transformed, nil + } raw := l[0] original := raw.(map[string]interface{}) transformed := make(map[string]interface{}) @@ -3140,6 +3363,141 @@ func expandCloudRunServiceSpecTemplateSpecContainersStartupProbeHttpGetHttpHeade return v, nil } +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbe(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedInitialDelaySeconds, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeInitialDelaySeconds(original["initial_delay_seconds"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedInitialDelaySeconds); val.IsValid() && !isEmptyValue(val) { + transformed["initialDelaySeconds"] = transformedInitialDelaySeconds + } + + transformedTimeoutSeconds, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeTimeoutSeconds(original["timeout_seconds"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedTimeoutSeconds); val.IsValid() && !isEmptyValue(val) { + transformed["timeoutSeconds"] = transformedTimeoutSeconds + } + + transformedPeriodSeconds, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbePeriodSeconds(original["period_seconds"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedPeriodSeconds); val.IsValid() && !isEmptyValue(val) { + transformed["periodSeconds"] = transformedPeriodSeconds + } + + transformedFailureThreshold, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeFailureThreshold(original["failure_threshold"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedFailureThreshold); val.IsValid() && !isEmptyValue(val) { + transformed["failureThreshold"] = transformedFailureThreshold + } + + transformedHttpGet, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGet(original["http_get"], d, config) + if err != nil { + return nil, err + } else { + transformed["httpGet"] = transformedHttpGet + } + + return transformed, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeInitialDelaySeconds(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeTimeoutSeconds(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbePeriodSeconds(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeFailureThreshold(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGet(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 { + return nil, nil + } + + if l[0] == nil { + transformed := make(map[string]interface{}) + return transformed, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedPath, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetPath(original["path"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedPath); val.IsValid() && !isEmptyValue(val) { + transformed["path"] = transformedPath + } + + transformedHttpHeaders, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeaders(original["http_headers"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedHttpHeaders); val.IsValid() && !isEmptyValue(val) { + transformed["httpHeaders"] = transformedHttpHeaders + } + + return transformed, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetPath(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeaders(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + l := v.([]interface{}) + req := make([]interface{}, 0, len(l)) + for _, raw := range l { + if raw == nil { + continue + } + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedName, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersName(original["name"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedName); val.IsValid() && !isEmptyValue(val) { + transformed["name"] = transformedName + } + + transformedValue, err := expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersValue(original["value"], d, config) + if err != nil { + return nil, err + } else { + transformed["value"] = transformedValue + } + + req = append(req, transformed) + } + return req, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + +func expandCloudRunServiceSpecTemplateSpecContainersLivenessProbeHttpGetHttpHeadersValue(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + func expandCloudRunServiceSpecTemplateSpecContainerConcurrency(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { return v, nil } diff --git a/google-beta/resource_cloud_run_service_generated_test.go b/google-beta/resource_cloud_run_service_generated_test.go index c321ec08c1..232d5a48b0 100644 --- a/google-beta/resource_cloud_run_service_generated_test.go +++ b/google-beta/resource_cloud_run_service_generated_test.go @@ -511,6 +511,11 @@ resource "google_cloud_run_service" "default" { port = 8080 } } + liveness_probe { + http_get { + path = "/" + } + } } } } diff --git a/google-beta/resource_cloud_run_service_test.go b/google-beta/resource_cloud_run_service_test.go index faa4c1aebd..17120092ba 100644 --- a/google-beta/resource_cloud_run_service_test.go +++ b/google-beta/resource_cloud_run_service_test.go @@ -370,7 +370,7 @@ func TestAccCloudRunService_probes(t *testing.T) { Providers: testAccProviders, Steps: []resource.TestStep{ { - Config: testAccCloudRunService_cloudRunServiceWithEmptyTCPStartupProbe(name, project), + Config: testAccCloudRunService_cloudRunServiceWithEmptyTCPStartupProbeAndHTTPLivenessProbe(name, project), }, { ResourceName: "google_cloud_run_service.default", @@ -379,7 +379,7 @@ func TestAccCloudRunService_probes(t *testing.T) { ImportStateVerifyIgnore: []string{"metadata.0.resource_version", "status.0.conditions"}, }, { - Config: testAccCloudRunService_cloudRunServiceUpdateWithTCPStartupProbe(name, project, "2", "1", "5", "2"), + Config: testAccCloudRunService_cloudRunServiceUpdateWithTCPStartupProbeAndHTTPLivenessProbe(name, project, "2", "1", "5", "2"), }, { ResourceName: "google_cloud_run_service.default", @@ -409,7 +409,7 @@ func TestAccCloudRunService_probes(t *testing.T) { }) } -func testAccCloudRunService_cloudRunServiceWithEmptyTCPStartupProbe(name, project string) string { +func testAccCloudRunService_cloudRunServiceWithEmptyTCPStartupProbeAndHTTPLivenessProbe(name, project string) string { return fmt.Sprintf(` resource "google_cloud_run_service" "default" { name = "%s" @@ -433,6 +433,9 @@ resource "google_cloud_run_service" "default" { startup_probe { tcp_socket {} } + liveness_probe { + http_get {} + } } } } @@ -446,7 +449,7 @@ resource "google_cloud_run_service" "default" { `, name, project) } -func testAccCloudRunService_cloudRunServiceUpdateWithTCPStartupProbe(name, project, delay, timeout, peroid, failure_threshold string) string { +func testAccCloudRunService_cloudRunServiceUpdateWithTCPStartupProbeAndHTTPLivenessProbe(name, project, delay, timeout, peroid, failure_threshold string) string { return fmt.Sprintf(` resource "google_cloud_run_service" "default" { name = "%s" @@ -476,6 +479,22 @@ resource "google_cloud_run_service" "default" { port = 8080 } } + liveness_probe { + initial_delay_seconds = %s + period_seconds = %s + timeout_seconds = %s + failure_threshold = %s + http_get { + path = "/some-path" + http_headers { + name = "User-Agent" + value = "magic-modules" + } + http_headers { + name = "Some-Name" + } + } + } } } } @@ -486,7 +505,7 @@ resource "google_cloud_run_service" "default" { ] } } -`, name, project, delay, peroid, timeout, failure_threshold) +`, name, project, delay, peroid, timeout, failure_threshold, delay, peroid, timeout, failure_threshold) } func testAccCloudRunService_cloudRunServiceUpdateWithEmptyHTTPStartupProbe(name, project string) string { diff --git a/website/docs/r/cloud_run_service.html.markdown b/website/docs/r/cloud_run_service.html.markdown index bea46b2076..621b39e6e3 100644 --- a/website/docs/r/cloud_run_service.html.markdown +++ b/website/docs/r/cloud_run_service.html.markdown @@ -173,6 +173,11 @@ resource "google_cloud_run_service" "default" { port = 8080 } } + liveness_probe { + http_get { + path = "/" + } + } } } } @@ -424,8 +429,16 @@ The following arguments are supported: Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it succeeds. Container will not be added to service endpoints if the probe fails. + More info: + https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes Structure is [documented below](#nested_startup_probe). +* `liveness_probe` - + (Optional, [Beta](https://terraform.io/docs/providers/google/guides/provider_versions.html)) + Periodic probe of container liveness. Container will be restarted if the probe fails. More info: + https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes + Structure is [documented below](#nested_liveness_probe). + The `env_from` block supports: @@ -624,6 +637,58 @@ The following arguments are supported: Structure is [documented below](#nested_http_headers). +The `http_headers` block supports: + +* `name` - + (Required) + The header field name. + +* `value` - + (Optional) + The header field value. + +The `liveness_probe` block supports: + +* `initial_delay_seconds` - + (Optional) + Number of seconds after the container has started before the probe is + initiated. + Defaults to 0 seconds. Minimum value is 0. Maximum value is 3600. + +* `timeout_seconds` - + (Optional) + Number of seconds after which the probe times out. + Defaults to 1 second. Minimum value is 1. Maximum value is 3600. + Must be smaller than period_seconds. + +* `period_seconds` - + (Optional) + How often (in seconds) to perform the probe. + Default to 10 seconds. Minimum value is 1. Maximum value is 3600. + +* `failure_threshold` - + (Optional) + Minimum consecutive failures for the probe to be considered failed after + having succeeded. Defaults to 3. Minimum value is 1. + +* `http_get` - + (Optional) + HttpGet specifies the http request to perform. + Structure is [documented below](#nested_http_get). + + +The `http_get` block supports: + +* `path` - + (Optional) + Path to access on the HTTP server. If set, it should not be empty string. + +* `http_headers` - + (Optional) + Custom headers to set in the request. HTTP allows repeated headers. + Structure is [documented below](#nested_http_headers). + + The `http_headers` block supports: * `name` -