aws-cdk-lib 2.139.1__py3-none-any.whl → 2.141.0__py3-none-any.whl

aws_cdk/aws_route53/__init__.py

@@ -104,6 +104,21 @@ route53.ARecord(self, "ARecord",
 )
 ```
 
+To create an A record of type alias with target set to another record created outside CDK:
+
+### This function registers the given input i.e. DNS Name(string) of an existing record as an AliasTarget to the new ARecord. To register a target that is created as part of CDK use this instead https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_route53_targets-readme.html
+
+```python
+# my_zone: route53.HostedZone
+
+target_record = "existing.record.cdk.local"
+record = route53.ARecord.from_aRecord_attributes(self, "A",
+    zone=my_zone,
+    record_name="test",
+    target_dNS=target_record
+)
+```
+
 To add an AAAA record pointing to a CloudFront distribution:
 
 ```python
@@ -10094,6 +10109,304 @@ class ARecord(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="fromARecordAttributes")
+    @builtins.classmethod
+    def from_a_record_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        target_dns: builtins.str,
+        zone: IHostedZone,
+        comment: typing.Optional[builtins.str] = None,
+        delete_existing: typing.Optional[builtins.bool] = None,
+        geo_location: typing.Optional[GeoLocation] = None,
+        multi_value_answer: typing.Optional[builtins.bool] = None,
+        record_name: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        set_identifier: typing.Optional[builtins.str] = None,
+        ttl: typing.Optional[_Duration_4839e8c3] = None,
+        weight: typing.Optional[jsii.Number] = None,
+    ) -> "ARecord":
+        '''Creates new A record of type alias with target set to an existing A Record DNS.
+
+        Use when the target A record is created outside of CDK
+        For records created as part of CDK use
+
+        :param scope: the parent Construct for this Construct.
+        :param id: Logical Id of the resource.
+        :param target_dns: Existing A record DNS name to set RecordTarget.
+        :param zone: The hosted zone in which to define the new record.
+        :param comment: A comment to add on the record. Default: no comment
+        :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
+        :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
+        :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
+        :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
+        :param set_identifier: A string used to distinguish between different records with the same combination of DNS name and type. It can only be set when either weight or geoLocation is defined. This parameter must be between 1 and 128 characters in length. Default: - Auto generated string
+        :param ttl: The resource record cache time to live (TTL). Default: Duration.minutes(30)
+        :param weight: Among resource record sets that have the same combination of DNS name and type, a value that determines the proportion of DNS queries that Amazon Route 53 responds to using the current resource record set. Route 53 calculates the sum of the weights for the resource record sets that have the same combination of DNS name and type. Route 53 then responds to queries based on the ratio of a resource's weight to the total. This value can be a number between 0 and 255. Default: - Do not set weighted routing
+
+        :return: AWS::Route53::RecordSet of type A with target alias set to existing A record
+
+        :aws-cdk-lib: /aws-route53-targets/route53-record.ts
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c76ad72e64542d58d5e33c28ccaca560dac09b21c920d094b7a0c2386fe42886)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        attrs = ARecordAttrs(
+            target_dns=target_dns,
+            zone=zone,
+            comment=comment,
+            delete_existing=delete_existing,
+            geo_location=geo_location,
+            multi_value_answer=multi_value_answer,
+            record_name=record_name,
+            region=region,
+            set_identifier=set_identifier,
+            ttl=ttl,
+            weight=weight,
+        )
+
+        return typing.cast("ARecord", jsii.sinvoke(cls, "fromARecordAttributes", [scope, id, attrs]))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_route53.ARecordAttrs",
+    jsii_struct_bases=[RecordSetOptions],
+    name_mapping={
+        "zone": "zone",
+        "comment": "comment",
+        "delete_existing": "deleteExisting",
+        "geo_location": "geoLocation",
+        "multi_value_answer": "multiValueAnswer",
+        "record_name": "recordName",
+        "region": "region",
+        "set_identifier": "setIdentifier",
+        "ttl": "ttl",
+        "weight": "weight",
+        "target_dns": "targetDNS",
+    },
+)
+class ARecordAttrs(RecordSetOptions):
+    def __init__(
+        self,
+        *,
+        zone: IHostedZone,
+        comment: typing.Optional[builtins.str] = None,
+        delete_existing: typing.Optional[builtins.bool] = None,
+        geo_location: typing.Optional[GeoLocation] = None,
+        multi_value_answer: typing.Optional[builtins.bool] = None,
+        record_name: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        set_identifier: typing.Optional[builtins.str] = None,
+        ttl: typing.Optional[_Duration_4839e8c3] = None,
+        weight: typing.Optional[jsii.Number] = None,
+        target_dns: builtins.str,
+    ) -> None:
+        '''Construction properties to import existing ARecord as target.
+
+        :param zone: The hosted zone in which to define the new record.
+        :param comment: A comment to add on the record. Default: no comment
+        :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
+        :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
+        :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
+        :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
+        :param set_identifier: A string used to distinguish between different records with the same combination of DNS name and type. It can only be set when either weight or geoLocation is defined. This parameter must be between 1 and 128 characters in length. Default: - Auto generated string
+        :param ttl: The resource record cache time to live (TTL). Default: Duration.minutes(30)
+        :param weight: Among resource record sets that have the same combination of DNS name and type, a value that determines the proportion of DNS queries that Amazon Route 53 responds to using the current resource record set. Route 53 calculates the sum of the weights for the resource record sets that have the same combination of DNS name and type. Route 53 then responds to queries based on the ratio of a resource's weight to the total. This value can be a number between 0 and 255. Default: - Do not set weighted routing
+        :param target_dns: Existing A record DNS name to set RecordTarget.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # my_zone: route53.HostedZone
+            
+            target_record = "existing.record.cdk.local"
+            record = route53.ARecord.from_aRecord_attributes(self, "A",
+                zone=my_zone,
+                record_name="test",
+                target_dNS=target_record
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__514d7eccc21be019febe80e121fd7d979162668b63cb99051c629ef087f5fe9a)
+            check_type(argname="argument zone", value=zone, expected_type=type_hints["zone"])
+            check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
+            check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
+            check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
+            check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
+            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+            check_type(argname="argument set_identifier", value=set_identifier, expected_type=type_hints["set_identifier"])
+            check_type(argname="argument ttl", value=ttl, expected_type=type_hints["ttl"])
+            check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
+            check_type(argname="argument target_dns", value=target_dns, expected_type=type_hints["target_dns"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "zone": zone,
+            "target_dns": target_dns,
+        }
+        if comment is not None:
+            self._values["comment"] = comment
+        if delete_existing is not None:
+            self._values["delete_existing"] = delete_existing
+        if geo_location is not None:
+            self._values["geo_location"] = geo_location
+        if multi_value_answer is not None:
+            self._values["multi_value_answer"] = multi_value_answer
+        if record_name is not None:
+            self._values["record_name"] = record_name
+        if region is not None:
+            self._values["region"] = region
+        if set_identifier is not None:
+            self._values["set_identifier"] = set_identifier
+        if ttl is not None:
+            self._values["ttl"] = ttl
+        if weight is not None:
+            self._values["weight"] = weight
+
+    @builtins.property
+    def zone(self) -> IHostedZone:
+        '''The hosted zone in which to define the new record.'''
+        result = self._values.get("zone")
+        assert result is not None, "Required property 'zone' is missing"
+        return typing.cast(IHostedZone, result)
+
+    @builtins.property
+    def comment(self) -> typing.Optional[builtins.str]:
+        '''A comment to add on the record.
+
+        :default: no comment
+        '''
+        result = self._values.get("comment")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def delete_existing(self) -> typing.Optional[builtins.bool]:
+        '''Whether to delete the same record set in the hosted zone if it already exists (dangerous!).
+
+        This allows to deploy a new record set while minimizing the downtime because the
+        new record set will be created immediately after the existing one is deleted. It
+        also avoids "manual" actions to delete existing record sets.
+        .. epigraph::
+
+           **N.B.:** this feature is dangerous, use with caution! It can only be used safely when
+           ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing
+           an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment
+           will delete the record!
+
+        :default: false
+        '''
+        result = self._values.get("delete_existing")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def geo_location(self) -> typing.Optional[GeoLocation]:
+        '''The geographical origin for this record to return DNS records based on the user's location.'''
+        result = self._values.get("geo_location")
+        return typing.cast(typing.Optional[GeoLocation], result)
+
+    @builtins.property
+    def multi_value_answer(self) -> typing.Optional[builtins.bool]:
+        '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
+
+        :default: false
+        '''
+        result = self._values.get("multi_value_answer")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def record_name(self) -> typing.Optional[builtins.str]:
+        '''The subdomain name for this record. This should be relative to the zone root name.
+
+        For example, if you want to create a record for acme.example.com, specify
+        "acme".
+
+        You can also specify the fully qualified domain name which terminates with a
+        ".". For example, "acme.example.com.".
+
+        :default: zone root
+        '''
+        result = self._values.get("record_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def region(self) -> typing.Optional[builtins.str]:
+        '''The Amazon EC2 Region where you created the resource that this resource record set refers to.
+
+        The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer,
+        and is referred to by an IP address or a DNS domain name, depending on the record type.
+
+        When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets,
+        Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region.
+        Route 53 then returns the value that is associated with the selected resource record set.
+
+        :default: - Do not set latency based routing
+
+        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-route53-recordset.html#cfn-route53-recordset-region
+        '''
+        result = self._values.get("region")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def set_identifier(self) -> typing.Optional[builtins.str]:
+        '''A string used to distinguish between different records with the same combination of DNS name and type.
+
+        It can only be set when either weight or geoLocation is defined.
+
+        This parameter must be between 1 and 128 characters in length.
+
+        :default: - Auto generated string
+        '''
+        result = self._values.get("set_identifier")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def ttl(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The resource record cache time to live (TTL).
+
+        :default: Duration.minutes(30)
+        '''
+        result = self._values.get("ttl")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def weight(self) -> typing.Optional[jsii.Number]:
+        '''Among resource record sets that have the same combination of DNS name and type, a value that determines the proportion of DNS queries that Amazon Route 53 responds to using the current resource record set.
+
+        Route 53 calculates the sum of the weights for the resource record sets that have the same combination of DNS name and type.
+        Route 53 then responds to queries based on the ratio of a resource's weight to the total.
+
+        This value can be a number between 0 and 255.
+
+        :default: - Do not set weighted routing
+
+        :see: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html
+        '''
+        result = self._values.get("weight")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def target_dns(self) -> builtins.str:
+        '''Existing A record DNS name to set RecordTarget.'''
+        result = self._values.get("target_dns")
+        assert result is not None, "Required property 'target_dns' is missing"
+        return typing.cast(builtins.str, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ARecordAttrs(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_route53.ARecordProps",
@@ -13137,6 +13450,7 @@ class CaaAmazonRecord(
 
 __all__ = [
     "ARecord",
+    "ARecordAttrs",
     "ARecordProps",
     "AaaaRecord",
     "AaaaRecordProps",
@@ -14316,6 +14630,42 @@ def _typecheckingstub__ca2e60ba6b2baeeff2cc875c86af94b4b26d6f11c1cfcca09280ac533
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c76ad72e64542d58d5e33c28ccaca560dac09b21c920d094b7a0c2386fe42886(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    target_dns: builtins.str,
+    zone: IHostedZone,
+    comment: typing.Optional[builtins.str] = None,
+    delete_existing: typing.Optional[builtins.bool] = None,
+    geo_location: typing.Optional[GeoLocation] = None,
+    multi_value_answer: typing.Optional[builtins.bool] = None,
+    record_name: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
+    set_identifier: typing.Optional[builtins.str] = None,
+    ttl: typing.Optional[_Duration_4839e8c3] = None,
+    weight: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__514d7eccc21be019febe80e121fd7d979162668b63cb99051c629ef087f5fe9a(
+    *,
+    zone: IHostedZone,
+    comment: typing.Optional[builtins.str] = None,
+    delete_existing: typing.Optional[builtins.bool] = None,
+    geo_location: typing.Optional[GeoLocation] = None,
+    multi_value_answer: typing.Optional[builtins.bool] = None,
+    record_name: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
+    set_identifier: typing.Optional[builtins.str] = None,
+    ttl: typing.Optional[_Duration_4839e8c3] = None,
+    weight: typing.Optional[jsii.Number] = None,
+    target_dns: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a73a5c86411a0d853fcfad820ed58f5a5c19df65a7b2756560958db5cbe36569(
     *,
     zone: IHostedZone,