api.dev.rt.parque.cloud already exists in stack arn:aws:cloudformation:us-east-1:834896107245:stack/dev-rt-test-api/47c3a270-8c5e-11eb-88a6-0ed5acf75591

import * as sst from "@serverless-stack/resources";
import {Certificate, CertificateValidation} from "@aws-cdk/aws-certificatemanager";
import {HostedZone} from '@aws-cdk/aws-route53';
import {CfnOutput} from "@aws-cdk/core";
import {ApiAuthorizationType} from "@serverless-stack/resources";
import * as cdk from "@aws-cdk/core";

function createCertificate(scope: sst.Stack, app: <http://sst.App|sst.App>, id: string, props?: sst.StackProps): Certificate {
    const domain_name = `${app.stage}.rt.parque.cloud`;

    const hosted_zone = HostedZone.fromLookup(scope, 'HostedZone', {
        domainName: domain_name,
    });

    const certificate: Certificate = new Certificate(scope, "CustomDomainCertificate", {
        domainName: `*.${domain_name}`,
        validation: CertificateValidation.fromDns(hosted_zone),
    });

    new CfnOutput(scope, "CertificateArn", {
        value: certificate.certificateArn,
    });

    return certificate;
}

function createBooksApi(stack: sst.Stack, app: <http://sst.App|sst.App>, id: string, props?: sst.StackProps): sst.Api {
    const books_api: sst.Api = new sst.Api(stack, id, {
        accessLog:
            "$context.identity.sourceIp,$context.requestTime,$context.httpMethod,$context.routeKey,$context.protocol,$context.status,$context.responseLength,$context.requestId",
        customDomain: {
            domainName: "api.dev.rt.parque.cloud",
            hostedZone: "dev.rt.parque.cloud",
            path: "books",
            certificate: Certificate.fromCertificateArn(
                stack,
                "books-api-certificate",
                'arn:aws:acm:us-east-1:834896107245:certificate/d9f2ee08-fc7b-4b09-819e-d0289f904ac4'
            ),
        },
        defaultAuthorizationType: ApiAuthorizationType.AWS_IAM,
        defaultFunctionProps: {
            timeout: 30,
            environment: {
                STAGE: app.stage
            }
        },
        routes: {
            "POST   /": "sample-app/books-api/books-api.createBook",
            "GET    /{uri}": "sample-app/books-api/books-api.readBook",
            "PUT    /{uri}": "sample-app/books-api/books-api.updateBook",
            "DELETE /{uri}": "sample-app/books-api/books-api.deleteBook",
            "GET    /": "sample-app/books-api/books-api.findBook",
        }
    });

    books_api.attachPermissions(["dynamodb"]);

    return books_api;
}

function createAuth(stack: sst.Stack, app: <http://sst.App|sst.App>, id: string, props?: sst.StackProps): sst.Auth {
    // Create auth provider
    const auth = new sst.Auth(stack, id, {
        // Create a Cognito User Pool to manage user's authentication info.
        cognito: {
            // Users will login using their email and password
            signInAliases: {email: true},
        },
    });

    new cdk.CfnOutput(stack, "UserPoolId", {
        value: auth.cognitoUserPool!.userPoolId,
    });
    new cdk.CfnOutput(stack, "UserPoolClientId", {
        value: auth.cognitoUserPoolClient!.userPoolClientId,
    });
    new cdk.CfnOutput(stack, "IdentityPoolId", {
        value: auth.cognitoCfnIdentityPool.ref,
    });

    return auth;
}

function createUsersApi(stack: sst.Stack, app: <http://sst.App|sst.App>, id: string, props?: sst.StackProps): sst.Api {
    const users_api: sst.Api = new sst.Api(stack, id, {
        accessLog:
            "$context.identity.sourceIp,$context.requestTime,$context.httpMethod,$context.routeKey,$context.protocol,$context.status,$context.responseLength,$context.requestId",
        customDomain: {
            domainName: "api.dev.rt.parque.cloud",
            hostedZone: "dev.rt.parque.cloud",
            path: "users",
            certificate: Certificate.fromCertificateArn(
                stack,
                "users-api-certificate",
                'arn:aws:acm:us-east-1:834896107245:certificate/d9f2ee08-fc7b-4b09-819e-d0289f904ac4'
            ),
        },
        defaultAuthorizationType: ApiAuthorizationType.AWS_IAM,
        defaultFunctionProps: {
            timeout: 30,
            environment: {
                STAGE: app.stage
            }
        },
        routes: {
            "POST   /": "sample-app/users-api/users-api.createUser",
            "GET    /{uri}": "sample-app/users-api/users-api.readUser",
            "PUT    /{uri}": "sample-app/users-api/users-api.updateUser",
            "DELETE /{uri}": "sample-app/users-api/users-api.deleteUser",
            "GET    /": "sample-app/users-api/users-api.findUser",
        }
    });

    users_api.attachPermissions(["dynamodb"]);

    return users_api;
}

export default class TestApiStack extends sst.Stack {
    constructor(app: <http://sst.App|sst.App>, id: string, props?: sst.StackProps) {
        super(app, id, props);

        createCertificate(this, app, 'certificate');
        const auth: sst.Auth = createAuth(this, app, 'users-auth');
        const users_api: sst.Api = createUsersApi(this, app, 'users-api');
        const books_api: sst.Api = createBooksApi(this, app, 'books-api');

        auth.attachPermissionsForAuthUsers([users_api, books_api]);
    }
}

Api.ts

sst/resources

customDomain: {
    domainName: apigatewayv2.DomainName.fromDomainNameAttributes(
        stack,
        "books-api-domain",
        {
            name: 'api.dev.rt.parque.cloud',
            regionalDomainName: 'api.dev.rt.parque.cloud',
            regionalHostedZoneId: 'dev.rt.parque.cloud',
        }
    ),
    path: "books"
},

apigatewayv2.DomainName.fromDomainNameAttributes

this.apiV3 = new sst.Api(this, `${id}_apiV3`, {
      customDomain: {
        domainName: apigatewayv2.DomainName.fromDomainNameAttributes(
          this,
          'PeasyCustomDomain',
          {
            name: domainName,
            regionalDomainName: domainName,
            regionalHostedZoneId: '<http://peasy.nu|peasy.nu>'
          }
        ),
        certificate: certificatemanager.Certificate.fromCertificateArn(
          this,
          'PeasyCustomCertificate',
          certArn[scope.stage]
        )
      },
....

Error: Cannot configure the "certificate" when the "domainName" is a construct

path

.build/cdk.out