pulumi-newrelic 5.16.0a1698964311__py3-none-any.whl → 5.58.0a1763707205__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-newrelic might be problematic. Click here for more details.
- pulumi_newrelic/__init__.py +58 -1
- pulumi_newrelic/_inputs.py +10772 -2775
- pulumi_newrelic/_utilities.py +92 -11
- pulumi_newrelic/account_management.py +56 -42
- pulumi_newrelic/alert_channel.py +177 -151
- pulumi_newrelic/alert_condition.py +313 -301
- pulumi_newrelic/alert_muting_rule.py +195 -138
- pulumi_newrelic/alert_policy.py +157 -109
- pulumi_newrelic/alert_policy_channel.py +95 -81
- pulumi_newrelic/api_access_key.py +191 -209
- pulumi_newrelic/browser_application.py +161 -153
- pulumi_newrelic/cloud/__init__.py +3 -1
- pulumi_newrelic/cloud/_inputs.py +4267 -2710
- pulumi_newrelic/cloud/aws_govcloud_integrations.py +238 -200
- pulumi_newrelic/cloud/aws_govcloud_link_account.py +159 -212
- pulumi_newrelic/cloud/aws_integrations.py +518 -1490
- pulumi_newrelic/cloud/aws_link_account.py +88 -76
- pulumi_newrelic/cloud/azure_integrations.py +681 -587
- pulumi_newrelic/cloud/azure_link_account.py +129 -117
- pulumi_newrelic/cloud/gcp_integrations.py +436 -408
- pulumi_newrelic/cloud/gcp_link_account.py +71 -59
- pulumi_newrelic/cloud/oci_link_account.py +926 -0
- pulumi_newrelic/cloud/outputs.py +1678 -2317
- pulumi_newrelic/config/__init__.py +2 -1
- pulumi_newrelic/config/__init__.pyi +45 -0
- pulumi_newrelic/config/vars.py +22 -17
- pulumi_newrelic/data_partition_rule.py +129 -117
- pulumi_newrelic/entity_tags.py +153 -31
- pulumi_newrelic/events_to_metrics_rule.py +114 -102
- pulumi_newrelic/get_account.py +41 -29
- pulumi_newrelic/get_alert_channel.py +73 -28
- pulumi_newrelic/get_alert_policy.py +83 -34
- pulumi_newrelic/get_application.py +51 -39
- pulumi_newrelic/get_authentication_domain.py +111 -0
- pulumi_newrelic/get_cloud_account.py +43 -31
- pulumi_newrelic/get_entity.py +126 -121
- pulumi_newrelic/get_group.py +190 -0
- pulumi_newrelic/get_key_transaction.py +117 -38
- pulumi_newrelic/get_notification_destination.py +86 -36
- pulumi_newrelic/get_obfuscation_expression.py +47 -35
- pulumi_newrelic/get_service_level_alert_helper.py +237 -137
- pulumi_newrelic/get_test_grok_pattern.py +47 -32
- pulumi_newrelic/get_user.py +165 -0
- pulumi_newrelic/group.py +286 -0
- pulumi_newrelic/infra_alert_condition.py +400 -382
- pulumi_newrelic/insights/__init__.py +2 -1
- pulumi_newrelic/insights/_inputs.py +94 -23
- pulumi_newrelic/insights/event.py +56 -48
- pulumi_newrelic/insights/outputs.py +51 -18
- pulumi_newrelic/key_transaction.py +465 -0
- pulumi_newrelic/log_parsing_rule.py +169 -153
- pulumi_newrelic/monitor_downtime.py +914 -0
- pulumi_newrelic/notification_channel.py +560 -418
- pulumi_newrelic/notification_destination.py +379 -124
- pulumi_newrelic/nrql_alert_condition.py +945 -513
- pulumi_newrelic/nrql_drop_rule.py +121 -129
- pulumi_newrelic/obfuscation_expression.py +88 -76
- pulumi_newrelic/obfuscation_rule.py +123 -109
- pulumi_newrelic/one_dashboard.py +118 -108
- pulumi_newrelic/one_dashboard_json.py +77 -67
- pulumi_newrelic/one_dashboard_raw.py +214 -202
- pulumi_newrelic/outputs.py +5491 -2141
- pulumi_newrelic/pipeline_cloud_rule.py +335 -0
- pulumi_newrelic/plugins/__init__.py +2 -1
- pulumi_newrelic/plugins/_inputs.py +520 -90
- pulumi_newrelic/plugins/application_settings.py +463 -167
- pulumi_newrelic/plugins/outputs.py +337 -75
- pulumi_newrelic/plugins/workload.py +387 -151
- pulumi_newrelic/provider.py +156 -142
- pulumi_newrelic/pulumi-plugin.json +2 -1
- pulumi_newrelic/service_level.py +277 -255
- pulumi_newrelic/synthetics/__init__.py +2 -1
- pulumi_newrelic/synthetics/_inputs.py +275 -106
- pulumi_newrelic/synthetics/alert_condition.py +174 -160
- pulumi_newrelic/synthetics/broken_links_monitor.py +367 -207
- pulumi_newrelic/synthetics/cert_check_monitor.py +380 -218
- pulumi_newrelic/synthetics/get_private_location.py +51 -39
- pulumi_newrelic/synthetics/get_secure_credential.py +39 -27
- pulumi_newrelic/synthetics/monitor.py +668 -462
- pulumi_newrelic/synthetics/multi_location_alert_condition.py +219 -201
- pulumi_newrelic/synthetics/outputs.py +102 -85
- pulumi_newrelic/synthetics/private_location.py +120 -110
- pulumi_newrelic/synthetics/script_monitor.py +623 -375
- pulumi_newrelic/synthetics/secure_credential.py +99 -93
- pulumi_newrelic/synthetics/step_monitor.py +545 -201
- pulumi_newrelic/user.py +366 -0
- pulumi_newrelic/workflow.py +348 -312
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/METADATA +8 -7
- pulumi_newrelic-5.58.0a1763707205.dist-info/RECORD +92 -0
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/WHEEL +1 -1
- pulumi_newrelic-5.16.0a1698964311.dist-info/RECORD +0 -82
- {pulumi_newrelic-5.16.0a1698964311.dist-info → pulumi_newrelic-5.58.0a1763707205.dist-info}/top_level.txt +0 -0
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,27 +21,30 @@ __all__ = ['CertCheckMonitorArgs', 'CertCheckMonitor']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class CertCheckMonitorArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
certificate_expiration: pulumi.Input[int],
|
|
20
|
-
domain: pulumi.Input[str],
|
|
21
|
-
period: pulumi.Input[str],
|
|
22
|
-
status: pulumi.Input[str],
|
|
23
|
-
account_id: Optional[pulumi.Input[
|
|
24
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
25
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
26
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
27
|
-
|
|
24
|
+
certificate_expiration: pulumi.Input[_builtins.int],
|
|
25
|
+
domain: pulumi.Input[_builtins.str],
|
|
26
|
+
period: pulumi.Input[_builtins.str],
|
|
27
|
+
status: pulumi.Input[_builtins.str],
|
|
28
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
31
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None,
|
|
35
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
28
36
|
"""
|
|
29
37
|
The set of arguments for constructing a CertCheckMonitor resource.
|
|
30
|
-
:param pulumi.Input[int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
31
|
-
:param pulumi.Input[str] domain: The domain of the host that will have its certificate checked.
|
|
32
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
33
|
-
:param pulumi.Input[str] status: The run state of the monitor. (
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
:param pulumi.Input[
|
|
37
|
-
:param pulumi.Input[
|
|
38
|
-
:param pulumi.Input[
|
|
39
|
-
:param pulumi.Input[str]
|
|
38
|
+
:param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
39
|
+
:param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
|
|
40
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
41
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
42
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
43
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
44
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
45
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
46
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
47
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
40
48
|
:param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
41
49
|
"""
|
|
42
50
|
pulumi.set(__self__, "certificate_expiration", certificate_expiration)
|
|
@@ -51,108 +59,136 @@ class CertCheckMonitorArgs:
|
|
|
51
59
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
52
60
|
if name is not None:
|
|
53
61
|
pulumi.set(__self__, "name", name)
|
|
62
|
+
if runtime_type is not None:
|
|
63
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
64
|
+
if runtime_type_version is not None:
|
|
65
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
54
66
|
if tags is not None:
|
|
55
67
|
pulumi.set(__self__, "tags", tags)
|
|
68
|
+
if use_unsupported_legacy_runtime is not None:
|
|
69
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
56
70
|
|
|
57
|
-
@property
|
|
71
|
+
@_builtins.property
|
|
58
72
|
@pulumi.getter(name="certificateExpiration")
|
|
59
|
-
def certificate_expiration(self) -> pulumi.Input[int]:
|
|
73
|
+
def certificate_expiration(self) -> pulumi.Input[_builtins.int]:
|
|
60
74
|
"""
|
|
61
75
|
The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
62
76
|
"""
|
|
63
77
|
return pulumi.get(self, "certificate_expiration")
|
|
64
78
|
|
|
65
79
|
@certificate_expiration.setter
|
|
66
|
-
def certificate_expiration(self, value: pulumi.Input[int]):
|
|
80
|
+
def certificate_expiration(self, value: pulumi.Input[_builtins.int]):
|
|
67
81
|
pulumi.set(self, "certificate_expiration", value)
|
|
68
82
|
|
|
69
|
-
@property
|
|
83
|
+
@_builtins.property
|
|
70
84
|
@pulumi.getter
|
|
71
|
-
def domain(self) -> pulumi.Input[str]:
|
|
85
|
+
def domain(self) -> pulumi.Input[_builtins.str]:
|
|
72
86
|
"""
|
|
73
87
|
The domain of the host that will have its certificate checked.
|
|
74
88
|
"""
|
|
75
89
|
return pulumi.get(self, "domain")
|
|
76
90
|
|
|
77
91
|
@domain.setter
|
|
78
|
-
def domain(self, value: pulumi.Input[str]):
|
|
92
|
+
def domain(self, value: pulumi.Input[_builtins.str]):
|
|
79
93
|
pulumi.set(self, "domain", value)
|
|
80
94
|
|
|
81
|
-
@property
|
|
95
|
+
@_builtins.property
|
|
82
96
|
@pulumi.getter
|
|
83
|
-
def period(self) -> pulumi.Input[str]:
|
|
97
|
+
def period(self) -> pulumi.Input[_builtins.str]:
|
|
84
98
|
"""
|
|
85
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
99
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
86
100
|
"""
|
|
87
101
|
return pulumi.get(self, "period")
|
|
88
102
|
|
|
89
103
|
@period.setter
|
|
90
|
-
def period(self, value: pulumi.Input[str]):
|
|
104
|
+
def period(self, value: pulumi.Input[_builtins.str]):
|
|
91
105
|
pulumi.set(self, "period", value)
|
|
92
106
|
|
|
93
|
-
@property
|
|
107
|
+
@_builtins.property
|
|
94
108
|
@pulumi.getter
|
|
95
|
-
def status(self) -> pulumi.Input[str]:
|
|
109
|
+
def status(self) -> pulumi.Input[_builtins.str]:
|
|
96
110
|
"""
|
|
97
|
-
The run state of the monitor. (
|
|
98
|
-
|
|
99
|
-
> **NOTE:** The `MUTED` status will be deprecated in a future release, and it is recommended to refrain from using it.
|
|
111
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
100
112
|
"""
|
|
101
113
|
return pulumi.get(self, "status")
|
|
102
114
|
|
|
103
115
|
@status.setter
|
|
104
|
-
def status(self, value: pulumi.Input[str]):
|
|
116
|
+
def status(self, value: pulumi.Input[_builtins.str]):
|
|
105
117
|
pulumi.set(self, "status", value)
|
|
106
118
|
|
|
107
|
-
@property
|
|
119
|
+
@_builtins.property
|
|
108
120
|
@pulumi.getter(name="accountId")
|
|
109
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
121
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
110
122
|
"""
|
|
111
123
|
The account in which the Synthetics monitor will be created.
|
|
112
124
|
"""
|
|
113
125
|
return pulumi.get(self, "account_id")
|
|
114
126
|
|
|
115
127
|
@account_id.setter
|
|
116
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
128
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
117
129
|
pulumi.set(self, "account_id", value)
|
|
118
130
|
|
|
119
|
-
@property
|
|
131
|
+
@_builtins.property
|
|
120
132
|
@pulumi.getter(name="locationsPrivates")
|
|
121
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
133
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
122
134
|
"""
|
|
123
135
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
124
136
|
"""
|
|
125
137
|
return pulumi.get(self, "locations_privates")
|
|
126
138
|
|
|
127
139
|
@locations_privates.setter
|
|
128
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
140
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
129
141
|
pulumi.set(self, "locations_privates", value)
|
|
130
142
|
|
|
131
|
-
@property
|
|
143
|
+
@_builtins.property
|
|
132
144
|
@pulumi.getter(name="locationsPublics")
|
|
133
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
145
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
134
146
|
"""
|
|
135
|
-
The location the monitor will run from.
|
|
147
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
136
148
|
"""
|
|
137
149
|
return pulumi.get(self, "locations_publics")
|
|
138
150
|
|
|
139
151
|
@locations_publics.setter
|
|
140
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
152
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
141
153
|
pulumi.set(self, "locations_publics", value)
|
|
142
154
|
|
|
143
|
-
@property
|
|
155
|
+
@_builtins.property
|
|
144
156
|
@pulumi.getter
|
|
145
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
157
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
146
158
|
"""
|
|
147
159
|
The name for the monitor.
|
|
148
160
|
"""
|
|
149
161
|
return pulumi.get(self, "name")
|
|
150
162
|
|
|
151
163
|
@name.setter
|
|
152
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
164
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
153
165
|
pulumi.set(self, "name", value)
|
|
154
166
|
|
|
155
|
-
@property
|
|
167
|
+
@_builtins.property
|
|
168
|
+
@pulumi.getter(name="runtimeType")
|
|
169
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
170
|
+
"""
|
|
171
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
172
|
+
"""
|
|
173
|
+
return pulumi.get(self, "runtime_type")
|
|
174
|
+
|
|
175
|
+
@runtime_type.setter
|
|
176
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
177
|
+
pulumi.set(self, "runtime_type", value)
|
|
178
|
+
|
|
179
|
+
@_builtins.property
|
|
180
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
181
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
182
|
+
"""
|
|
183
|
+
The specific semver version of the runtime type.
|
|
184
|
+
"""
|
|
185
|
+
return pulumi.get(self, "runtime_type_version")
|
|
186
|
+
|
|
187
|
+
@runtime_type_version.setter
|
|
188
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
189
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
190
|
+
|
|
191
|
+
@_builtins.property
|
|
156
192
|
@pulumi.getter
|
|
157
193
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]:
|
|
158
194
|
"""
|
|
@@ -164,33 +200,47 @@ class CertCheckMonitorArgs:
|
|
|
164
200
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]):
|
|
165
201
|
pulumi.set(self, "tags", value)
|
|
166
202
|
|
|
203
|
+
@_builtins.property
|
|
204
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
205
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
206
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
207
|
+
|
|
208
|
+
@use_unsupported_legacy_runtime.setter
|
|
209
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
210
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
211
|
+
|
|
167
212
|
|
|
168
213
|
@pulumi.input_type
|
|
169
214
|
class _CertCheckMonitorState:
|
|
170
215
|
def __init__(__self__, *,
|
|
171
|
-
account_id: Optional[pulumi.Input[
|
|
172
|
-
certificate_expiration: Optional[pulumi.Input[int]] = None,
|
|
173
|
-
domain: Optional[pulumi.Input[str]] = None,
|
|
174
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
175
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
216
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
217
|
+
certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
218
|
+
domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
219
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
220
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
221
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
222
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
223
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
224
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
225
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
226
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
227
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
228
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]] = None,
|
|
229
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
181
230
|
"""
|
|
182
231
|
Input properties used for looking up and filtering CertCheckMonitor resources.
|
|
183
|
-
:param pulumi.Input[
|
|
184
|
-
:param pulumi.Input[int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
185
|
-
:param pulumi.Input[str] domain: The domain of the host that will have its certificate checked.
|
|
186
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
187
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
188
|
-
:param pulumi.Input[str]
|
|
189
|
-
:param pulumi.Input[str]
|
|
190
|
-
:param pulumi.Input[
|
|
191
|
-
:param pulumi.Input[
|
|
192
|
-
|
|
193
|
-
|
|
232
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
233
|
+
:param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
234
|
+
:param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
|
|
235
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
236
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
237
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
|
|
238
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
239
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
240
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
241
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
242
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
243
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
194
244
|
:param pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
195
245
|
"""
|
|
196
246
|
if account_id is not None:
|
|
@@ -203,128 +253,170 @@ class _CertCheckMonitorState:
|
|
|
203
253
|
pulumi.set(__self__, "locations_privates", locations_privates)
|
|
204
254
|
if locations_publics is not None:
|
|
205
255
|
pulumi.set(__self__, "locations_publics", locations_publics)
|
|
256
|
+
if monitor_id is not None:
|
|
257
|
+
pulumi.set(__self__, "monitor_id", monitor_id)
|
|
206
258
|
if name is not None:
|
|
207
259
|
pulumi.set(__self__, "name", name)
|
|
208
260
|
if period is not None:
|
|
209
261
|
pulumi.set(__self__, "period", period)
|
|
210
262
|
if period_in_minutes is not None:
|
|
211
263
|
pulumi.set(__self__, "period_in_minutes", period_in_minutes)
|
|
264
|
+
if runtime_type is not None:
|
|
265
|
+
pulumi.set(__self__, "runtime_type", runtime_type)
|
|
266
|
+
if runtime_type_version is not None:
|
|
267
|
+
pulumi.set(__self__, "runtime_type_version", runtime_type_version)
|
|
212
268
|
if status is not None:
|
|
213
269
|
pulumi.set(__self__, "status", status)
|
|
214
270
|
if tags is not None:
|
|
215
271
|
pulumi.set(__self__, "tags", tags)
|
|
272
|
+
if use_unsupported_legacy_runtime is not None:
|
|
273
|
+
pulumi.set(__self__, "use_unsupported_legacy_runtime", use_unsupported_legacy_runtime)
|
|
216
274
|
|
|
217
|
-
@property
|
|
275
|
+
@_builtins.property
|
|
218
276
|
@pulumi.getter(name="accountId")
|
|
219
|
-
def account_id(self) -> Optional[pulumi.Input[
|
|
277
|
+
def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
220
278
|
"""
|
|
221
279
|
The account in which the Synthetics monitor will be created.
|
|
222
280
|
"""
|
|
223
281
|
return pulumi.get(self, "account_id")
|
|
224
282
|
|
|
225
283
|
@account_id.setter
|
|
226
|
-
def account_id(self, value: Optional[pulumi.Input[
|
|
284
|
+
def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
227
285
|
pulumi.set(self, "account_id", value)
|
|
228
286
|
|
|
229
|
-
@property
|
|
287
|
+
@_builtins.property
|
|
230
288
|
@pulumi.getter(name="certificateExpiration")
|
|
231
|
-
def certificate_expiration(self) -> Optional[pulumi.Input[int]]:
|
|
289
|
+
def certificate_expiration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
232
290
|
"""
|
|
233
291
|
The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
234
292
|
"""
|
|
235
293
|
return pulumi.get(self, "certificate_expiration")
|
|
236
294
|
|
|
237
295
|
@certificate_expiration.setter
|
|
238
|
-
def certificate_expiration(self, value: Optional[pulumi.Input[int]]):
|
|
296
|
+
def certificate_expiration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
239
297
|
pulumi.set(self, "certificate_expiration", value)
|
|
240
298
|
|
|
241
|
-
@property
|
|
299
|
+
@_builtins.property
|
|
242
300
|
@pulumi.getter
|
|
243
|
-
def domain(self) -> Optional[pulumi.Input[str]]:
|
|
301
|
+
def domain(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
244
302
|
"""
|
|
245
303
|
The domain of the host that will have its certificate checked.
|
|
246
304
|
"""
|
|
247
305
|
return pulumi.get(self, "domain")
|
|
248
306
|
|
|
249
307
|
@domain.setter
|
|
250
|
-
def domain(self, value: Optional[pulumi.Input[str]]):
|
|
308
|
+
def domain(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
251
309
|
pulumi.set(self, "domain", value)
|
|
252
310
|
|
|
253
|
-
@property
|
|
311
|
+
@_builtins.property
|
|
254
312
|
@pulumi.getter(name="locationsPrivates")
|
|
255
|
-
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
313
|
+
def locations_privates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
256
314
|
"""
|
|
257
315
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
258
316
|
"""
|
|
259
317
|
return pulumi.get(self, "locations_privates")
|
|
260
318
|
|
|
261
319
|
@locations_privates.setter
|
|
262
|
-
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
320
|
+
def locations_privates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
263
321
|
pulumi.set(self, "locations_privates", value)
|
|
264
322
|
|
|
265
|
-
@property
|
|
323
|
+
@_builtins.property
|
|
266
324
|
@pulumi.getter(name="locationsPublics")
|
|
267
|
-
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
325
|
+
def locations_publics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
268
326
|
"""
|
|
269
|
-
The location the monitor will run from.
|
|
327
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
270
328
|
"""
|
|
271
329
|
return pulumi.get(self, "locations_publics")
|
|
272
330
|
|
|
273
331
|
@locations_publics.setter
|
|
274
|
-
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
332
|
+
def locations_publics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
275
333
|
pulumi.set(self, "locations_publics", value)
|
|
276
334
|
|
|
277
|
-
@property
|
|
335
|
+
@_builtins.property
|
|
336
|
+
@pulumi.getter(name="monitorId")
|
|
337
|
+
def monitor_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
338
|
+
"""
|
|
339
|
+
The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
|
|
340
|
+
"""
|
|
341
|
+
return pulumi.get(self, "monitor_id")
|
|
342
|
+
|
|
343
|
+
@monitor_id.setter
|
|
344
|
+
def monitor_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
345
|
+
pulumi.set(self, "monitor_id", value)
|
|
346
|
+
|
|
347
|
+
@_builtins.property
|
|
278
348
|
@pulumi.getter
|
|
279
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
349
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
280
350
|
"""
|
|
281
351
|
The name for the monitor.
|
|
282
352
|
"""
|
|
283
353
|
return pulumi.get(self, "name")
|
|
284
354
|
|
|
285
355
|
@name.setter
|
|
286
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
356
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
287
357
|
pulumi.set(self, "name", value)
|
|
288
358
|
|
|
289
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
290
360
|
@pulumi.getter
|
|
291
|
-
def period(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
def period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
292
362
|
"""
|
|
293
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
363
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
294
364
|
"""
|
|
295
365
|
return pulumi.get(self, "period")
|
|
296
366
|
|
|
297
367
|
@period.setter
|
|
298
|
-
def period(self, value: Optional[pulumi.Input[str]]):
|
|
368
|
+
def period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
299
369
|
pulumi.set(self, "period", value)
|
|
300
370
|
|
|
301
|
-
@property
|
|
371
|
+
@_builtins.property
|
|
302
372
|
@pulumi.getter(name="periodInMinutes")
|
|
303
|
-
def period_in_minutes(self) -> Optional[pulumi.Input[int]]:
|
|
373
|
+
def period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
304
374
|
"""
|
|
305
375
|
The interval in minutes at which Synthetic monitor should run.
|
|
306
376
|
"""
|
|
307
377
|
return pulumi.get(self, "period_in_minutes")
|
|
308
378
|
|
|
309
379
|
@period_in_minutes.setter
|
|
310
|
-
def period_in_minutes(self, value: Optional[pulumi.Input[int]]):
|
|
380
|
+
def period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
311
381
|
pulumi.set(self, "period_in_minutes", value)
|
|
312
382
|
|
|
313
|
-
@property
|
|
314
|
-
@pulumi.getter
|
|
315
|
-
def
|
|
383
|
+
@_builtins.property
|
|
384
|
+
@pulumi.getter(name="runtimeType")
|
|
385
|
+
def runtime_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
386
|
+
"""
|
|
387
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
388
|
+
"""
|
|
389
|
+
return pulumi.get(self, "runtime_type")
|
|
390
|
+
|
|
391
|
+
@runtime_type.setter
|
|
392
|
+
def runtime_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
393
|
+
pulumi.set(self, "runtime_type", value)
|
|
394
|
+
|
|
395
|
+
@_builtins.property
|
|
396
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
397
|
+
def runtime_type_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
398
|
+
"""
|
|
399
|
+
The specific semver version of the runtime type.
|
|
316
400
|
"""
|
|
317
|
-
|
|
401
|
+
return pulumi.get(self, "runtime_type_version")
|
|
402
|
+
|
|
403
|
+
@runtime_type_version.setter
|
|
404
|
+
def runtime_type_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
405
|
+
pulumi.set(self, "runtime_type_version", value)
|
|
318
406
|
|
|
319
|
-
|
|
407
|
+
@_builtins.property
|
|
408
|
+
@pulumi.getter
|
|
409
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
410
|
+
"""
|
|
411
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
320
412
|
"""
|
|
321
413
|
return pulumi.get(self, "status")
|
|
322
414
|
|
|
323
415
|
@status.setter
|
|
324
|
-
def status(self, value: Optional[pulumi.Input[str]]):
|
|
416
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
325
417
|
pulumi.set(self, "status", value)
|
|
326
418
|
|
|
327
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
328
420
|
@pulumi.getter
|
|
329
421
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]:
|
|
330
422
|
"""
|
|
@@ -336,43 +428,58 @@ class _CertCheckMonitorState:
|
|
|
336
428
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CertCheckMonitorTagArgs']]]]):
|
|
337
429
|
pulumi.set(self, "tags", value)
|
|
338
430
|
|
|
431
|
+
@_builtins.property
|
|
432
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
433
|
+
def use_unsupported_legacy_runtime(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
434
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
435
|
+
|
|
436
|
+
@use_unsupported_legacy_runtime.setter
|
|
437
|
+
def use_unsupported_legacy_runtime(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
438
|
+
pulumi.set(self, "use_unsupported_legacy_runtime", value)
|
|
339
439
|
|
|
440
|
+
|
|
441
|
+
@pulumi.type_token("newrelic:synthetics/certCheckMonitor:CertCheckMonitor")
|
|
340
442
|
class CertCheckMonitor(pulumi.CustomResource):
|
|
341
443
|
@overload
|
|
342
444
|
def __init__(__self__,
|
|
343
445
|
resource_name: str,
|
|
344
446
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
345
|
-
account_id: Optional[pulumi.Input[
|
|
346
|
-
certificate_expiration: Optional[pulumi.Input[int]] = None,
|
|
347
|
-
domain: Optional[pulumi.Input[str]] = None,
|
|
348
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
349
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
350
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
351
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
352
|
-
|
|
353
|
-
|
|
447
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
448
|
+
certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
449
|
+
domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
450
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
451
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
452
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
453
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
454
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
455
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
456
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
457
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
|
|
458
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
354
459
|
__props__=None):
|
|
355
460
|
"""
|
|
356
|
-
Use this resource to create, update, and delete a Synthetics Certificate Check monitor in New Relic.
|
|
357
|
-
|
|
358
461
|
## Example Usage
|
|
359
462
|
|
|
360
463
|
```python
|
|
361
464
|
import pulumi
|
|
362
465
|
import pulumi_newrelic as newrelic
|
|
363
466
|
|
|
364
|
-
|
|
365
|
-
|
|
467
|
+
foo = newrelic.synthetics.CertCheckMonitor("foo",
|
|
468
|
+
name="Sample Cert Check Monitor",
|
|
366
469
|
domain="www.example.com",
|
|
367
470
|
locations_publics=["AP_SOUTH_1"],
|
|
471
|
+
certificate_expiration=10,
|
|
368
472
|
period="EVERY_6_HOURS",
|
|
369
473
|
status="ENABLED",
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
474
|
+
runtime_type="NODE_API",
|
|
475
|
+
runtime_type_version="16.10",
|
|
476
|
+
tags=[{
|
|
477
|
+
"key": "some_key",
|
|
478
|
+
"values": ["some_value"],
|
|
479
|
+
}])
|
|
374
480
|
```
|
|
375
481
|
See additional examples.
|
|
482
|
+
|
|
376
483
|
## Additional Examples
|
|
377
484
|
|
|
378
485
|
### Create a monitor with a private location
|
|
@@ -385,41 +492,46 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
385
492
|
import pulumi
|
|
386
493
|
import pulumi_newrelic as newrelic
|
|
387
494
|
|
|
388
|
-
|
|
389
|
-
|
|
495
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
496
|
+
name="Sample Private Location",
|
|
497
|
+
description="Sample Private Location Description",
|
|
390
498
|
verified_script_execution=False)
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
499
|
+
foo_cert_check_monitor = newrelic.synthetics.CertCheckMonitor("foo",
|
|
500
|
+
name="Sample Cert Check Monitor",
|
|
501
|
+
domain="www.one.example.com",
|
|
502
|
+
locations_privates=[foo.id],
|
|
503
|
+
certificate_expiration=10,
|
|
394
504
|
period="EVERY_6_HOURS",
|
|
395
505
|
status="ENABLED",
|
|
396
|
-
tags=[
|
|
397
|
-
key
|
|
398
|
-
values
|
|
399
|
-
|
|
506
|
+
tags=[{
|
|
507
|
+
"key": "some_key",
|
|
508
|
+
"values": ["some_value"],
|
|
509
|
+
}])
|
|
400
510
|
```
|
|
401
511
|
|
|
402
512
|
## Import
|
|
403
513
|
|
|
404
|
-
|
|
514
|
+
A cert check monitor can be imported using its GUID, using the following command.
|
|
515
|
+
|
|
516
|
+
bash
|
|
405
517
|
|
|
406
518
|
```sh
|
|
407
|
-
|
|
519
|
+
$ pulumi import newrelic:synthetics/certCheckMonitor:CertCheckMonitor monitor <guid>
|
|
408
520
|
```
|
|
409
521
|
|
|
410
522
|
:param str resource_name: The name of the resource.
|
|
411
523
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
412
|
-
:param pulumi.Input[
|
|
413
|
-
:param pulumi.Input[int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
414
|
-
:param pulumi.Input[str] domain: The domain of the host that will have its certificate checked.
|
|
415
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
416
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
417
|
-
:param pulumi.Input[str] name: The name for the monitor.
|
|
418
|
-
:param pulumi.Input[str] period: The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
419
|
-
:param pulumi.Input[str]
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
524
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
525
|
+
:param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
526
|
+
:param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
|
|
527
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
528
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
529
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
530
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
531
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
532
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
533
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
534
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
423
535
|
"""
|
|
424
536
|
...
|
|
425
537
|
@overload
|
|
@@ -428,26 +540,28 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
428
540
|
args: CertCheckMonitorArgs,
|
|
429
541
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
430
542
|
"""
|
|
431
|
-
Use this resource to create, update, and delete a Synthetics Certificate Check monitor in New Relic.
|
|
432
|
-
|
|
433
543
|
## Example Usage
|
|
434
544
|
|
|
435
545
|
```python
|
|
436
546
|
import pulumi
|
|
437
547
|
import pulumi_newrelic as newrelic
|
|
438
548
|
|
|
439
|
-
|
|
440
|
-
|
|
549
|
+
foo = newrelic.synthetics.CertCheckMonitor("foo",
|
|
550
|
+
name="Sample Cert Check Monitor",
|
|
441
551
|
domain="www.example.com",
|
|
442
552
|
locations_publics=["AP_SOUTH_1"],
|
|
553
|
+
certificate_expiration=10,
|
|
443
554
|
period="EVERY_6_HOURS",
|
|
444
555
|
status="ENABLED",
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
556
|
+
runtime_type="NODE_API",
|
|
557
|
+
runtime_type_version="16.10",
|
|
558
|
+
tags=[{
|
|
559
|
+
"key": "some_key",
|
|
560
|
+
"values": ["some_value"],
|
|
561
|
+
}])
|
|
449
562
|
```
|
|
450
563
|
See additional examples.
|
|
564
|
+
|
|
451
565
|
## Additional Examples
|
|
452
566
|
|
|
453
567
|
### Create a monitor with a private location
|
|
@@ -460,26 +574,31 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
460
574
|
import pulumi
|
|
461
575
|
import pulumi_newrelic as newrelic
|
|
462
576
|
|
|
463
|
-
|
|
464
|
-
|
|
577
|
+
foo = newrelic.synthetics.PrivateLocation("foo",
|
|
578
|
+
name="Sample Private Location",
|
|
579
|
+
description="Sample Private Location Description",
|
|
465
580
|
verified_script_execution=False)
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
581
|
+
foo_cert_check_monitor = newrelic.synthetics.CertCheckMonitor("foo",
|
|
582
|
+
name="Sample Cert Check Monitor",
|
|
583
|
+
domain="www.one.example.com",
|
|
584
|
+
locations_privates=[foo.id],
|
|
585
|
+
certificate_expiration=10,
|
|
469
586
|
period="EVERY_6_HOURS",
|
|
470
587
|
status="ENABLED",
|
|
471
|
-
tags=[
|
|
472
|
-
key
|
|
473
|
-
values
|
|
474
|
-
|
|
588
|
+
tags=[{
|
|
589
|
+
"key": "some_key",
|
|
590
|
+
"values": ["some_value"],
|
|
591
|
+
}])
|
|
475
592
|
```
|
|
476
593
|
|
|
477
594
|
## Import
|
|
478
595
|
|
|
479
|
-
|
|
596
|
+
A cert check monitor can be imported using its GUID, using the following command.
|
|
597
|
+
|
|
598
|
+
bash
|
|
480
599
|
|
|
481
600
|
```sh
|
|
482
|
-
|
|
601
|
+
$ pulumi import newrelic:synthetics/certCheckMonitor:CertCheckMonitor monitor <guid>
|
|
483
602
|
```
|
|
484
603
|
|
|
485
604
|
:param str resource_name: The name of the resource.
|
|
@@ -497,15 +616,18 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
497
616
|
def _internal_init(__self__,
|
|
498
617
|
resource_name: str,
|
|
499
618
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
500
|
-
account_id: Optional[pulumi.Input[
|
|
501
|
-
certificate_expiration: Optional[pulumi.Input[int]] = None,
|
|
502
|
-
domain: Optional[pulumi.Input[str]] = None,
|
|
503
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
504
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
505
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
506
|
-
period: Optional[pulumi.Input[str]] = None,
|
|
507
|
-
|
|
508
|
-
|
|
619
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
620
|
+
certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
621
|
+
domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
622
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
623
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
624
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
625
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
626
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
627
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
628
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
629
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
|
|
630
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
509
631
|
__props__=None):
|
|
510
632
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
511
633
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -528,10 +650,14 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
528
650
|
if period is None and not opts.urn:
|
|
529
651
|
raise TypeError("Missing required property 'period'")
|
|
530
652
|
__props__.__dict__["period"] = period
|
|
653
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
654
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
531
655
|
if status is None and not opts.urn:
|
|
532
656
|
raise TypeError("Missing required property 'status'")
|
|
533
657
|
__props__.__dict__["status"] = status
|
|
534
658
|
__props__.__dict__["tags"] = tags
|
|
659
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
660
|
+
__props__.__dict__["monitor_id"] = None
|
|
535
661
|
__props__.__dict__["period_in_minutes"] = None
|
|
536
662
|
super(CertCheckMonitor, __self__).__init__(
|
|
537
663
|
'newrelic:synthetics/certCheckMonitor:CertCheckMonitor',
|
|
@@ -543,16 +669,20 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
543
669
|
def get(resource_name: str,
|
|
544
670
|
id: pulumi.Input[str],
|
|
545
671
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
546
|
-
account_id: Optional[pulumi.Input[
|
|
547
|
-
certificate_expiration: Optional[pulumi.Input[int]] = None,
|
|
548
|
-
domain: Optional[pulumi.Input[str]] = None,
|
|
549
|
-
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
550
|
-
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
672
|
+
account_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
673
|
+
certificate_expiration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
674
|
+
domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
675
|
+
locations_privates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
676
|
+
locations_publics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
677
|
+
monitor_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
678
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
679
|
+
period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
680
|
+
period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
681
|
+
runtime_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
682
|
+
runtime_type_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
683
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
684
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]]] = None,
|
|
685
|
+
use_unsupported_legacy_runtime: Optional[pulumi.Input[_builtins.bool]] = None) -> 'CertCheckMonitor':
|
|
556
686
|
"""
|
|
557
687
|
Get an existing CertCheckMonitor resource's state with the given name, id, and optional extra
|
|
558
688
|
properties used to qualify the lookup.
|
|
@@ -560,18 +690,19 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
560
690
|
:param str resource_name: The unique name of the resulting resource.
|
|
561
691
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
562
692
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
563
|
-
:param pulumi.Input[
|
|
564
|
-
:param pulumi.Input[int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
565
|
-
:param pulumi.Input[str] domain: The domain of the host that will have its certificate checked.
|
|
566
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
567
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] locations_publics: The location the monitor will run from.
|
|
568
|
-
:param pulumi.Input[str]
|
|
569
|
-
:param pulumi.Input[str]
|
|
570
|
-
:param pulumi.Input[
|
|
571
|
-
:param pulumi.Input[
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
:param pulumi.Input[
|
|
693
|
+
:param pulumi.Input[_builtins.str] account_id: The account in which the Synthetics monitor will be created.
|
|
694
|
+
:param pulumi.Input[_builtins.int] certificate_expiration: The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
695
|
+
:param pulumi.Input[_builtins.str] domain: The domain of the host that will have its certificate checked.
|
|
696
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_privates: The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
697
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] locations_publics: The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
698
|
+
:param pulumi.Input[_builtins.str] monitor_id: The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
|
|
699
|
+
:param pulumi.Input[_builtins.str] name: The name for the monitor.
|
|
700
|
+
:param pulumi.Input[_builtins.str] period: The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
701
|
+
:param pulumi.Input[_builtins.int] period_in_minutes: The interval in minutes at which Synthetic monitor should run.
|
|
702
|
+
:param pulumi.Input[_builtins.str] runtime_type: The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
703
|
+
:param pulumi.Input[_builtins.str] runtime_type_version: The specific semver version of the runtime type.
|
|
704
|
+
:param pulumi.Input[_builtins.str] status: The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
705
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['CertCheckMonitorTagArgs', 'CertCheckMonitorTagArgsDict']]]] tags: The tags that will be associated with the monitor. See Nested tag blocks below for details
|
|
575
706
|
"""
|
|
576
707
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
577
708
|
|
|
@@ -582,88 +713,114 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
582
713
|
__props__.__dict__["domain"] = domain
|
|
583
714
|
__props__.__dict__["locations_privates"] = locations_privates
|
|
584
715
|
__props__.__dict__["locations_publics"] = locations_publics
|
|
716
|
+
__props__.__dict__["monitor_id"] = monitor_id
|
|
585
717
|
__props__.__dict__["name"] = name
|
|
586
718
|
__props__.__dict__["period"] = period
|
|
587
719
|
__props__.__dict__["period_in_minutes"] = period_in_minutes
|
|
720
|
+
__props__.__dict__["runtime_type"] = runtime_type
|
|
721
|
+
__props__.__dict__["runtime_type_version"] = runtime_type_version
|
|
588
722
|
__props__.__dict__["status"] = status
|
|
589
723
|
__props__.__dict__["tags"] = tags
|
|
724
|
+
__props__.__dict__["use_unsupported_legacy_runtime"] = use_unsupported_legacy_runtime
|
|
590
725
|
return CertCheckMonitor(resource_name, opts=opts, __props__=__props__)
|
|
591
726
|
|
|
592
|
-
@property
|
|
727
|
+
@_builtins.property
|
|
593
728
|
@pulumi.getter(name="accountId")
|
|
594
|
-
def account_id(self) -> pulumi.Output[
|
|
729
|
+
def account_id(self) -> pulumi.Output[_builtins.str]:
|
|
595
730
|
"""
|
|
596
731
|
The account in which the Synthetics monitor will be created.
|
|
597
732
|
"""
|
|
598
733
|
return pulumi.get(self, "account_id")
|
|
599
734
|
|
|
600
|
-
@property
|
|
735
|
+
@_builtins.property
|
|
601
736
|
@pulumi.getter(name="certificateExpiration")
|
|
602
|
-
def certificate_expiration(self) -> pulumi.Output[int]:
|
|
737
|
+
def certificate_expiration(self) -> pulumi.Output[_builtins.int]:
|
|
603
738
|
"""
|
|
604
739
|
The desired number of remaining days until the certificate expires to trigger a monitor failure.
|
|
605
740
|
"""
|
|
606
741
|
return pulumi.get(self, "certificate_expiration")
|
|
607
742
|
|
|
608
|
-
@property
|
|
743
|
+
@_builtins.property
|
|
609
744
|
@pulumi.getter
|
|
610
|
-
def domain(self) -> pulumi.Output[str]:
|
|
745
|
+
def domain(self) -> pulumi.Output[_builtins.str]:
|
|
611
746
|
"""
|
|
612
747
|
The domain of the host that will have its certificate checked.
|
|
613
748
|
"""
|
|
614
749
|
return pulumi.get(self, "domain")
|
|
615
750
|
|
|
616
|
-
@property
|
|
751
|
+
@_builtins.property
|
|
617
752
|
@pulumi.getter(name="locationsPrivates")
|
|
618
|
-
def locations_privates(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
753
|
+
def locations_privates(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
619
754
|
"""
|
|
620
755
|
The location the monitor will run from. Accepts a list of private location GUIDs. At least one of either `locations_public` or `locations_private` is required.
|
|
621
756
|
"""
|
|
622
757
|
return pulumi.get(self, "locations_privates")
|
|
623
758
|
|
|
624
|
-
@property
|
|
759
|
+
@_builtins.property
|
|
625
760
|
@pulumi.getter(name="locationsPublics")
|
|
626
|
-
def locations_publics(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
761
|
+
def locations_publics(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
627
762
|
"""
|
|
628
|
-
The location the monitor will run from.
|
|
763
|
+
The location the monitor will run from. Check out [this page](https://docs.newrelic.com/docs/synthetics/synthetic-monitoring/administration/synthetic-public-minion-ips/) for a list of valid public locations. You don't need the `AWS_` prefix as the provider uses NerdGraph. At least one of either `locations_public` or `location_private` is required.
|
|
629
764
|
"""
|
|
630
765
|
return pulumi.get(self, "locations_publics")
|
|
631
766
|
|
|
632
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
768
|
+
@pulumi.getter(name="monitorId")
|
|
769
|
+
def monitor_id(self) -> pulumi.Output[_builtins.str]:
|
|
770
|
+
"""
|
|
771
|
+
The monitor id of the certificate check synthetics monitor (not to be confused with the GUID of the monitor).
|
|
772
|
+
"""
|
|
773
|
+
return pulumi.get(self, "monitor_id")
|
|
774
|
+
|
|
775
|
+
@_builtins.property
|
|
633
776
|
@pulumi.getter
|
|
634
|
-
def name(self) -> pulumi.Output[str]:
|
|
777
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
635
778
|
"""
|
|
636
779
|
The name for the monitor.
|
|
637
780
|
"""
|
|
638
781
|
return pulumi.get(self, "name")
|
|
639
782
|
|
|
640
|
-
@property
|
|
783
|
+
@_builtins.property
|
|
641
784
|
@pulumi.getter
|
|
642
|
-
def period(self) -> pulumi.Output[str]:
|
|
785
|
+
def period(self) -> pulumi.Output[_builtins.str]:
|
|
643
786
|
"""
|
|
644
|
-
The interval at which this monitor should run. Valid values are EVERY_MINUTE
|
|
787
|
+
The interval at which this monitor should run. Valid values are `EVERY_MINUTE`, `EVERY_5_MINUTES`, `EVERY_10_MINUTES`, `EVERY_15_MINUTES`, `EVERY_30_MINUTES`, `EVERY_HOUR`, `EVERY_6_HOURS`, `EVERY_12_HOURS`, or `EVERY_DAY`.
|
|
645
788
|
"""
|
|
646
789
|
return pulumi.get(self, "period")
|
|
647
790
|
|
|
648
|
-
@property
|
|
791
|
+
@_builtins.property
|
|
649
792
|
@pulumi.getter(name="periodInMinutes")
|
|
650
|
-
def period_in_minutes(self) -> pulumi.Output[int]:
|
|
793
|
+
def period_in_minutes(self) -> pulumi.Output[_builtins.int]:
|
|
651
794
|
"""
|
|
652
795
|
The interval in minutes at which Synthetic monitor should run.
|
|
653
796
|
"""
|
|
654
797
|
return pulumi.get(self, "period_in_minutes")
|
|
655
798
|
|
|
656
|
-
@property
|
|
657
|
-
@pulumi.getter
|
|
658
|
-
def
|
|
799
|
+
@_builtins.property
|
|
800
|
+
@pulumi.getter(name="runtimeType")
|
|
801
|
+
def runtime_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
802
|
+
"""
|
|
803
|
+
The runtime that the monitor will use to run jobs (`NODE_API`).
|
|
659
804
|
"""
|
|
660
|
-
|
|
805
|
+
return pulumi.get(self, "runtime_type")
|
|
661
806
|
|
|
662
|
-
|
|
807
|
+
@_builtins.property
|
|
808
|
+
@pulumi.getter(name="runtimeTypeVersion")
|
|
809
|
+
def runtime_type_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
810
|
+
"""
|
|
811
|
+
The specific semver version of the runtime type.
|
|
812
|
+
"""
|
|
813
|
+
return pulumi.get(self, "runtime_type_version")
|
|
814
|
+
|
|
815
|
+
@_builtins.property
|
|
816
|
+
@pulumi.getter
|
|
817
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
818
|
+
"""
|
|
819
|
+
The run state of the monitor. (`ENABLED` or `DISABLED`).
|
|
663
820
|
"""
|
|
664
821
|
return pulumi.get(self, "status")
|
|
665
822
|
|
|
666
|
-
@property
|
|
823
|
+
@_builtins.property
|
|
667
824
|
@pulumi.getter
|
|
668
825
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.CertCheckMonitorTag']]]:
|
|
669
826
|
"""
|
|
@@ -671,3 +828,8 @@ class CertCheckMonitor(pulumi.CustomResource):
|
|
|
671
828
|
"""
|
|
672
829
|
return pulumi.get(self, "tags")
|
|
673
830
|
|
|
831
|
+
@_builtins.property
|
|
832
|
+
@pulumi.getter(name="useUnsupportedLegacyRuntime")
|
|
833
|
+
def use_unsupported_legacy_runtime(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
834
|
+
return pulumi.get(self, "use_unsupported_legacy_runtime")
|
|
835
|
+
|