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