쿠키 기본 설정 선택

당사는 사이트와 서비스를 제공하는 데 필요한 필수 쿠키 및 유사한 도구를 사용합니다. 고객이 사이트를 어떻게 사용하는지 파악하고 개선할 수 있도록 성능 쿠키를 사용해 익명의 통계를 수집합니다. 필수 쿠키는 비활성화할 수 없지만 '사용자 지정' 또는 ‘거부’를 클릭하여 성능 쿠키를 거부할 수 있습니다.

사용자가 동의하는 경우 AWS와 승인된 제3자도 쿠키를 사용하여 유용한 사이트 기능을 제공하고, 사용자의 기본 설정을 기억하고, 관련 광고를 비롯한 관련 콘텐츠를 표시합니다. 필수가 아닌 모든 쿠키를 수락하거나 거부하려면 ‘수락’ 또는 ‘거부’를 클릭하세요. 더 자세한 내용을 선택하려면 ‘사용자 정의’를 클릭하세요.

설정
문의하기
피드백
AWS Documentation
AWS 계정 생성

AWS CDK 스택 소개

RSS
포커스 모드
AWS CDK 스택 소개 - AWS Cloud Development Kit (AWS CDK) v2
스택 API 정보 스택 작업

v AWS CDK 2 개발자 안내서입니다. 이전 CDK v1은 2022년 6월 1일에 유지 관리에 들어갔으며 2023년 6월 1일에 지원이 종료되었습니다.

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

v AWS CDK 2 개발자 안내서입니다. 이전 CDK v1은 2022년 6월 1일에 유지 관리에 들어갔으며 2023년 6월 1일에 지원이 종료되었습니다.

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

AWS CDK 스택은 가장 작은 단일 배포 단위입니다. CDK 구문을 사용하여 정의하는 AWS 리소스 모음을 나타냅니다. CDK 앱을 배포하면 CDK 스택 내의 리소스가 AWS CloudFormation 스택으로 함께 배포됩니다. AWS CloudFormation 스택에 대한 자세한 내용은 AWS CloudFormation 사용 설명서의 AWS CloudFormation 스택을 사용하여 AWS 리소스를 단일 단위로 관리를 참조하세요.

Stack 구문을 확장하거나 이 구문에서 상속하여 스택을 정의합니다. 다음 예에서는 스택 파일이라고 하는 별도의 파일에 CDK 스택을 정의하기 위한 일반적인 패턴입니다. 여기서 Stack 클래스를 확장하거나 상속하고 scope, id, props를 수락하는 생성자를 정의합니다. 그런 다음 수신된 scope, id, props와 함께 super를 사용하여 기본 Stack 클래스 생성자를 간접적으로 호출합니다.

TypeScript
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}
JavaScript
const { Stack } = require('aws-cdk-lib');

class MyCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define your constructs here

  }
}

module.exports = { MyCdkStack }
Python
from aws_cdk import (
  Stack,
)
from constructs import Construct

class MyCdkStack(Stack):

  def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
    super().__init__(scope, construct_id, **kwargs)

    # Define your constructs here
Java
package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

public class MyCdkStack extends Stack {
  public MyCdkStack(final Construct scope, final String id) {  
    this(scope, id, null);
  }
  
  public MyCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define your constructs here
  }
}
C#
using Amazon.CDK; 
using Constructs;

namespace MyCdk
{
  public class MyCdkStack : Stack
  {
    internal MyCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}
Go
package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type CdkDemoAppStackProps struct {
	awscdk.StackProps
}

func NewCdkDemoAppStack(scope constructs.Construct, id string, props *CdkDemoAppStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return stack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewCdkDemoAppStack(app, "CdkDemoAppStack", &CdkDemoAppStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
} 

//...
anchoranchoranchoranchoranchoranchor
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

이전 예에서는 스택만 정의했습니다. 스택을 생성하려면 CDK 앱의 컨텍스트 내에서 스택을 인스턴스화해야 합니다. 일반적인 패턴은 CDK 앱을 정의하고 애플리케이션 파일이라고 하는 별도의 파일에서 스택을 초기화하는 것입니다.

다음은 MyCdkStack이라는 CDK 스택을 생성하는 예입니다. 여기서 CDK 앱이 생성되고 앱의 컨텍스트에서 MyCdkStack이 인스턴스화됩니다.

TypeScript
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkStack } from '../lib/my-cdk-stack';

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});
JavaScript
#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { MyCdkStack } = require('../lib/my-cdk-stack');

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});
Python

app.py에 위치합니다.

#!/usr/bin/env python3
import os

import aws_cdk as cdk

from my_cdk.my_cdk_stack import MyCdkStack


app = cdk.App()
MyCdkStack(app, "MyCdkStack",)

app.synth()
Java
package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class MyCdkApp {
  public static void main(final String[] args) {
    App app = new App();

    new MyCdkStack(app, "MyCdkStack", StackProps.builder()
      .build());

    app.synth();
  }
}
C#
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCdk
{
  sealed class Program
  {
    public static void Main(string[] args)
    {
      var app = new App();
      new MyCdkStack(app, "MyCdkStack", new StackProps
      {});
      app.Synth();
    }
  }
}
Go
package main

import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

// ...

func main() {
  defer jsii.Close()

  app := awscdk.NewApp(nil)

  NewMyCdkStack(app, "MyCdkStack", &MyCdkStackProps{
    awscdk.StackProps{
      Env: env(),
    },
  })

  app.Synth(nil)
}

// ...
anchoranchoranchoranchoranchoranchor
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkStack } from '../lib/my-cdk-stack';

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});

다음 예에서는 2개의 스택이 들어 있는 CDK 앱을 생성합니다.

TypeScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
JavaScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
Python
app = App()

MyFirstStack(app, 'stack1')
MySecondStack(app, 'stack2')

app.synth()
Java
App app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.synth();
C#
var app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.Synth();
Go
package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type MyFirstStackProps struct {
	awscdk.StackProps
}

func NewMyFirstStack(scope constructs.Construct, id string, props *MyFirstStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	myFirstStack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return myFirstStack
}

type MySecondStackProps struct {
	awscdk.StackProps
}

func NewMySecondStack(scope constructs.Construct, id string, props *MySecondStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	mySecondStack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return mySecondStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewMyFirstStack(app, "MyFirstStack", &MyFirstStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	NewMySecondStack(app, "MySecondStack", &MySecondStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
}

// ...
anchoranchoranchoranchoranchoranchor
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();

스택 API 정보

Stack 객체는 다음을 포함한 풍부한 API를 제공합니다.

  • Stack.of(construct) - 구문이 정의된 스택을 반환하는 정적 메서드입니다. 이는 재사용 가능한 구문 내에서 스택과 상호 작용해야 하는 경우에 유용합니다. 범위에서 스택을 찾을 수 없는 경우 직접 호출이 실패합니다.

  • stack.stackName(Python: stack_name) - 스택의 물리적 이름을 반환합니다. 앞서 언급한 것처럼 모든 AWS CDK 스택에는 합성 중에가 확인할 AWS CDK 수 있는 물리적 이름이 있습니다.

  • stack.region 및 stack.account -이 스택이 배포될 AWS 리전과 계정을 각각 반환합니다. 이들 속성은 다음 중 하나를 반환합니다.

    • 스택이 정의될 때 명시적으로 지정된 계정 또는 리전

    • 이 스택이 환경에 구애받지 않음을 나타내기 위해 계정 및 리전에 대한 AWS CloudFormation 의사 파라미터로 확인되는 문자열 인코딩 토큰

    스택에 대한 환경이 결정되는 방법에 대한 자세한 내용은 의 환경 AWS CDK 섹션을 참조하세요.

  • stack.addDependency(stack)(Python: stack.add_dependency(stack)) – 2개의 스택 간의 종속성 순서를 명시적으로 정의하는 데 사용할 수 있습니다. cdk deploy 명령은 여러 스택을 한 번에 배포할 때 이 순서를 따릅니다.

  • stack.tags - 스택 수준 태그를 추가하거나 제거하는 데 사용할 수 있는 TagManager를 반환합니다. 이 태그 관리자는 스택 내의 모든 리소스에 태그를 지정하고 스택이 생성될 때 스택 자체에도 태그를 지정합니다 AWS CloudFormation.

  • stack.partition, stack.urlSuffix (Python: url_suffix), stack.stackId (Python: stack_id) 및 stack.notificationArn (Python: notification_arn) AWS CloudFormation -와 같은 각 의사 파라미터로 확인되는 토큰을 반환합니다{ "Ref": "AWS::Partition" }. 이러한 토큰은 AWS CDK 프레임워크가 크로스 스택 참조를 식별할 수 있도록 특정 스택 객체와 연결됩니다.

  • stack.availabilityZones(Python: availability_zones) - 이 스택이 배포된 환경에서 사용 가능한 가용 영역 세트를 반환합니다. 환경에 관계없는 스택의 경우 이는 항상 가용 영역이 2개 있는 배열을 반환합니다. 환경별 스택의 경우는 환경을 AWS CDK 쿼리하고 지정한 리전에서 사용 가능한 정확한 가용 영역 세트를 반환합니다.

  • stack.parseArn(arn) 및 stack.formatArn(comps)(Python: parse_arn, format_arn) - Amazon 리소스 이름(ARN)으로 작업하는 데 사용할 수 있습니다.

  • stack.toJsonString(obj) (Python: to_json_string) - 템플릿에 포함할 수 있는 JSON 문자열로 임의 객체를 포맷하는 데 사용할 수 있습니다 AWS CloudFormation . 배포 중에만 확인되는 토큰, 속성 및 참조가 객체에 포함될 수 있습니다.

  • stack.templateOptions(Python: template_options) - 스택에 대한 변환, 설명 및 메타데이터와 같은 AWS CloudFormation 템플릿 옵션을 지정하는 데 사용합니다.

스택 작업

스택은 AWS 환경으로 AWS CloudFormation 스택으로 배포됩니다. 환경은 특정 AWS 계정 및를 다룹니다 AWS 리전.

여러 스택이 있는 앱에 대해 cdk synth 명령을 실행하면 클라우드 어셈블리에 각 스택 인스턴스에 대한 별도의 템플릿이 포함됩니다. 두 스택이 동일한 클래스의 인스턴스인 경우에도는 스택을 두 개의 개별 템플릿으로 AWS CDK 내보냅니다.

cdk synth 명령에서 스택 이름을 지정하여 각 템플릿을 합성할 수 있습니다. 다음 예에서는 stack1에 대한 템플릿을 합성합니다.

$ cdk synth stack1

이 접근 방식은 AWS CloudFormation 템플릿을 여러 번 배포하고 AWS CloudFormation 파라미터를 통해 파라미터를 지정할 수 있는 템플릿이 일반적으로 사용되는 방식과 개념적으로 다릅니다. AWS CloudFormation 파라미터는에서 정의할 수 있지만 AWS CDK배포 중에만 확인되므로 일반적으로 권장되지 AWS CloudFormation 않습니다. 즉, 코드에서 해당 값을 확인할 수 없습니다.

예를 들어 파라미터 값을 기반으로 앱에 리소스를 조건부로 포함하려면 AWS CloudFormation 조건을 설정하고 해당 조건으로 리소스에 태그를 지정해야 합니다. 는 합성 시 구체적인 템플릿이 확인되는 접근 방식을 AWS CDK 취합니다. 따라서 if 문으로 값을 확인하여 리소스를 정의해야 하는지 아니면 일부 동작을 적용해야 하는지 결정할 수 있습니다.

참고

AWS CDK 는 합성 시간 동안 가능한 한 많은 해상도를 제공하여 프로그래밍 언어를 이상적이고 자연스럽게 사용할 수 있도록 합니다.

다른 구문과 마찬가지로 스택을 그룹으로 구성할 수 있습니다. 다음 코드는 컨트롤 플레인, 데이터 플레인 및 모니터링 스택의 세 가지 스택으로 구성된 서비스의 예를 보여줍니다. 서비스 구문은 베타 환경용으로 한 번, 프로덕션 환경용으로 한 번, 총 두 번 정의됩니다.

TypeScript
import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();
JavaScript
const { App, Stack } = require('aws-cdk-lib');
const { Construct } = require('constructs');

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope, id, props) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");
  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();
Python
from aws_cdk import App, Stack
from constructs import Construct

# imagine these stacks declare a bunch of related resources
class ControlPlane(Stack): pass
class DataPlane(Stack): pass
class Monitoring(Stack): pass

class MyService(Construct):

  def __init__(self, scope: Construct, id: str, *, prod=False):
  
    super().__init__(scope, id)
  
    # we might use the prod argument to change how the service is configured
    ControlPlane(self, "cp")
    DataPlane(self, "data")
    Monitoring(self, "mon")
    
app = App();
MyService(app, "beta")
MyService(app, "prod", prod=True)

app.synth()
Java
package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Stack;
import software.constructs.Construct;

public class MyApp {

    // imagine these stacks declare a bunch of related resources
    static class ControlPlane extends Stack {
        ControlPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class DataPlane extends Stack {
        DataPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class Monitoring extends Stack {
        Monitoring(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class MyService extends Construct {
        MyService(Construct scope, String id) {
            this(scope, id, false);
        }
        
        MyService(Construct scope, String id, boolean prod) {
            super(scope, id);
            
            // we might use the prod argument to change how the service is configured
            new ControlPlane(this, "cp");
            new DataPlane(this, "data");
            new Monitoring(this, "mon");         
        }
    }
    
    public static void main(final String argv[]) {
        App app = new App();

        new MyService(app, "beta");
        new MyService(app, "prod", true);
        
        app.synth();
    }
}
C#
using Amazon.CDK;
using Constructs;

// imagine these stacks declare a bunch of related resources
public class ControlPlane : Stack {
    public ControlPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class DataPlane : Stack {
    public DataPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class Monitoring : Stack
{
    public Monitoring(Construct scope, string id=null) : base(scope, id) { }
}

public class MyService : Construct
{
    public MyService(Construct scope, string id, Boolean prod=false) : base(scope, id)
    {
        // we might use the prod argument to change how the service is configured
        new ControlPlane(this, "cp");
        new DataPlane(this, "data");
        new Monitoring(this, "mon");
    }
}

class Program
{
    static void Main(string[] args)
    {

        var app = new App();
        new MyService(app, "beta");
        new MyService(app, "prod", prod: true);
        app.Synth();
    }
}
Go
package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type ControlPlaneStackProps struct {
	awscdk.StackProps
}

func NewControlPlaneStack(scope constructs.Construct, id string, props *ControlPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	ControlPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return ControlPlaneStack
}

type DataPlaneStackProps struct {
	awscdk.StackProps
}

func NewDataPlaneStack(scope constructs.Construct, id string, props *DataPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	DataPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return DataPlaneStack
}

type MonitoringStackProps struct {
	awscdk.StackProps
}

func NewMonitoringStack(scope constructs.Construct, id string, props *MonitoringStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MonitoringStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return MonitoringStack
}

type MyServiceStackProps struct {
	awscdk.StackProps
	Prod bool
}

func NewMyServiceStack(scope constructs.Construct, id string, props *MyServiceStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MyServiceStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	NewControlPlaneStack(MyServiceStack, "cp", &ControlPlaneStackProps{
		StackProps: sprops,
	})
	NewDataPlaneStack(MyServiceStack, "data", &DataPlaneStackProps{
		StackProps: sprops,
	})
	NewMonitoringStack(MyServiceStack, "mon", &MonitoringStackProps{
		StackProps: sprops,
	})

	return MyServiceStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	betaProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: false,
	}

	NewMyServiceStack(app, "beta", &betaProps)

	prodProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: true,
	}

	NewMyServiceStack(app, "prod", &prodProps)

	app.Synth(nil)
}

// ...
anchoranchoranchoranchoranchoranchor
import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

이 AWS CDK 앱은 결국 6개의 스택으로 구성되며, 각 환경에 대해 3개입니다.

$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

AWS CloudFormation 스택의 물리적 이름은 트리에서 스택의 구문 경로를 AWS CDK 기반으로에 의해 자동으로 결정됩니다. 기본적으로 스택의 이름은 Stack 객체의 구문 ID에서 파생됩니다. 그러나 다음과 같이 stackName prop(Python: stack_name)을 사용하여 명시적 이름을 지정할 수 있습니다.

TypeScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
JavaScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
Python
MyStack(self, "not:a:stack:name", stack_name="this-is-stack-name")
Java
new MyStack(this, "not:a:stack:name", StackProps.builder()
    .StackName("this-is-stack-name").build());
C#
new MyStack(this, "not:a:stack:name", new StackProps
{
    StackName = "this-is-stack-name"
});
anchoranchoranchoranchoranchor
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });

중첩된 스택 작업

중첩된 스택은 부모 스택이라고 하는 다른 스택 내에 생성하는 CDK 스택입니다. NestedStack 구문을 사용하여 중첩된 스택을 생성합니다.

중첩된 스택을 사용하면 여러 스택에 걸쳐 리소스를 구성할 수 있습니다. 중첩 스택은 스택에 대한 AWS CloudFormation 500개 리소스 제한을 우회하는 방법도 제공합니다. 중첩된 스택은 해당 스택을 포함하는 스택에서 하나의 리소스로만 계산됩니다. 그러나 추가 중첩된 스택을 포함하여 최대 500개의 리소스를 포함할 수 있습니다.

중첩된 스택의 범위는 Stack 또는 NestedStack 구문이어야 합니다. 중첩된 스택은 부모 스택 내부에서 어휘적으로 선언될 필요가 없습니다. 중첩된 스택을 인스턴스화할 때 부모 스택을 첫 번째 파라미터(scope)로 전달하기만 하면 됩니다. 이러한 제한을 제외하면 중첩된 스택에서 구문을 정의하는 것은 일반 스택에서와 똑같습니다.

합성 시 중첩 스택은 배포 시 스테이징 버킷에 업로드되는 자체 AWS CloudFormation 템플릿으로 AWS CDK 합성됩니다. 중첩된 스택은 부모 스택에 바인딩되며 독립적인 배포 아티팩트로 처리되지 않습니다. cdk list에 의해 나열되지 않으며 cdk deploy에 의해 배포될 수 없습니다.

상위 스택과 중첩 스택 간의 참조는 교차 스택 참조와 마찬가지로 생성된 AWS CloudFormation 템플릿의 스택 파라미터 및 출력으로 자동 변환됩니다.

주의

중첩된 스택에 대한 배포 전에는 보안 태세의 변경 사항이 표시되지 않습니다. 이 정보는 최상위 스택에 대해서만 표시됩니다.

이 페이지에서

프라이버시사이트 이용 약관쿠키 기본 설정
© 2025, Amazon Web Services, Inc. 또는 계열사. All rights reserved.