Questa è la AWS CDK v2 Developer Guide. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione ed esecuzione della sintesi dello stack CDK
Prima di poter implementare uno stack AWS Cloud Development Kit (AWS CDK), è necessario sintetizzarlo. La *sintesi dello stack* è il processo di produzione di un AWS CloudFormation modello e di distribuzione degli artefatti da uno stack CDK. *Il modello e gli artefatti sono noti come assemblaggio cloud.* L'assemblaggio cloud è ciò su cui viene distribuito il provisioning delle risorse. AWS Per ulteriori informazioni su come funzionano le distribuzioni, consulta [Come funzionano le implementazioni AWS CDK](deploy.md#deploy-how).
## Come funzionano insieme la sintesi e il bootstrap
Affinché le app CDK vengano distribuite correttamente, i CloudFormation modelli prodotti durante la sintesi devono specificare correttamente le risorse create durante il bootstrap. Pertanto, il bootstrap e la sintesi devono integrarsi a vicenda affinché un'implementazione abbia successo:
+ Il bootstrap è un processo unico di configurazione di un AWS ambiente per le implementazioni CDK. AWS Configura AWS risorse specifiche nell'ambiente che vengono utilizzate dal CDK per le distribuzioni. *Queste sono comunemente chiamate risorse bootstrap.* Per istruzioni sul bootstrap, consulta [Bootstrap your environment for use](bootstrapping-env.md) with the CDK. AWS
+ CloudFormation i modelli prodotti durante la sintesi includono informazioni sulle risorse di bootstrap da utilizzare. Durante la sintesi, la CLI CDK non sa esattamente come è stato avviato AWS l'ambiente. Invece, la CLI CDK CloudFormation produce modelli basati sul sintetizzatore configurato per ogni stack CDK. Affinché una distribuzione abbia successo, il sintetizzatore deve produrre CloudFormation modelli che facciano riferimento alle risorse di bootstrap corrette da utilizzare.
Il CDK è dotato di un sintetizzatore e di una configurazione di bootstrap predefiniti progettati per funzionare insieme. Se ne personalizzi una, devi applicare le personalizzazioni pertinenti all'altra.
## Come configurare la sintesi dello stack CDK
Si configura la sintesi dello stack CDK utilizzando la `synthesizer` proprietà della propria istanza. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html) Questa proprietà specifica come verranno sintetizzati gli stack CDK. Fornisci un'istanza di una classe che implementa o. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IStackSynthesizer.html) I suoi metodi verranno richiamati ogni volta che una risorsa viene aggiunta allo stack o quando lo stack viene sintetizzato. Di seguito è riportato un esempio di base dell'utilizzo di questa proprietà all'interno dello stack:
**Example**
```
new MyStack(this, 'MyStack', {
// stack properties
synthesizer: new DefaultStackSynthesizer({
// synthesizer properties
}),
});
```
```
new MyStack(this, 'MyStack', {
// stack properties
synthesizer: new DefaultStackSynthesizer({
// synthesizer properties
}),
});
```
```
MyStack(self, "MyStack",
# stack properties
synthesizer=DefaultStackSynthesizer(
# synthesizer properties
))
```
```
new MyStack(app, "MyStack", StackProps.builder()
// stack properties
.synthesizer(DefaultStackSynthesizer.Builder.create()
// synthesizer properties
.build())
.build();
)
```
```
new MyStack(app, "MyStack", new StackProps
// stack properties
{
Synthesizer = new DefaultStackSynthesizer(new DefaultStackSynthesizerProps
{
// synthesizer properties
})
});
```
```
func main() {
app := awscdk.NewApp(nil)
NewMyStack(app, "MyStack", &MyStackProps{
StackProps: awscdk.StackProps{
Synthesizer: awscdk.NewDefaultStackSynthesizer(&awscdk.DefaultStackSynthesizerProps{
// synthesizer properties
}),
},
})
app.Synth(nil)
}
```
Puoi anche configurare un sintetizzatore per tutti gli stack CDK nell'app CDK utilizzando la proprietà dell'istanza: `defaultStackSynthesizer` `App`
**Example**
```
import { App, Stack, DefaultStackSynthesizer } from 'aws-cdk-lib';
const app = new App({
// Configure for all stacks in this app
defaultStackSynthesizer: new DefaultStackSynthesizer({
/* ... */
}),
});
```
```
const { App, Stack, DefaultStackSynthesizer } = require('aws-cdk-lib');
const app = new App({
// Configure for all stacks in this app
defaultStackSynthesizer: new DefaultStackSynthesizer({
/* ... */
}),
});
```
```
from aws_cdk import App, Stack, DefaultStackSynthesizer
app = App(
default_stack_synthesizer=DefaultStackSynthesizer(
# Configure for all stacks in this app
# ...
)
)
```
```
import software.amazon.awscdk.App;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.DefaultStackSynthesizer;
public class Main {
public static void main(final String[] args) {
App app = new App(AppProps.builder()
// Configure for all stacks in this app
.defaultStackSynthesizer(DefaultStackSynthesizer.Builder.create().build())
.build()
);
}
}
```
```
using Amazon.CDK;
using Amazon.CDK.Synthesizers;
namespace MyNamespace
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App(new AppProps
{
// Configure for all stacks in this app
DefaultStackSynthesizer = new DefaultStackSynthesizer(new DefaultStackSynthesizerProps
{
// ...
})
});
}
}
}
```
```
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(&awscdk.AppProps{
// Configure for all stacks in this app
DefaultStackSynthesizer: awscdk.NewDefaultStackSynthesizer(&awscdk.DefaultStackSynthesizerProps{
// ...
}),
})
}
```
Per impostazione predefinita, il CDK utilizza. AWS ` [`DefaultStackSynthesizer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html) ` Se non configuri un sintetizzatore, verrà utilizzato questo sintetizzatore.
Se non modificate il bootstrap, ad esempio apportando modifiche allo stack o al modello di bootstrap, non è necessario modificare la sintesi dello stack. Non è nemmeno necessario fornire un sintetizzatore. Il CDK utilizzerà la `DefaultStackSynthesizer` classe predefinita per configurare la sintesi dello stack CDK per interagire correttamente con lo stack bootstrap.
## Come sintetizzare uno stack CDK
Per sintetizzare uno stack CDK, utilizzate il comando CDK Command Line Interface ( AWS AWS CDK CLI). `cdk synth` [Per ulteriori informazioni su questo comando, incluse le opzioni che è possibile utilizzare con questo comando, vedete cdk synthesize.](ref-cli-cmd-synth.md)
Se l'app CDK contiene un singolo stack o per sintetizzare tutti gli stack, non è necessario fornire il nome dello stack CDK come argomento. Per impostazione predefinita, la CLI CDK sintetizza gli stack CDK in modelli. AWS CloudFormation Un modello `json` formattato per ogni stack viene salvato nella directory. `cdk.out` Se l'app contiene un singolo stack, viene stampato un modello `yaml` formattato su. `stdout` Di seguito è riportato un esempio:
```
$ cdk synth
Resources:
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:H4sIAAAAAAAA/unique-identifier
Metadata:
aws:cdk:path: CdkAppStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
...
```
Se l'app CDK contiene più stack, puoi fornire l'ID logico di uno stack per sintetizzare un singolo stack. Di seguito è riportato un esempio:
```
$ cdk synth MyStackName
```
Se non sintetizzi uno stack e non lo esegui`cdk deploy`, la CLI CDK sintetizzerà automaticamente lo stack prima della distribuzione.
## Come funziona la sintesi di default
**Logico generato IDs nel tuo AWS CloudFormation modello**
Quando sintetizzi uno stack CDK per produrre un CloudFormation modello, i dati logici IDs vengono generati dalle seguenti fonti, formattate come: `construct-pathconstruct-IDunique-hash`
+ Percorso di **costruzione: l'intero percorso** verso la costruzione nell'app CDK. Questo percorso esclude l'ID del costrutto L1, che è sempre `Resource` o`Default`, e l'ID dello stack di primo livello di cui fa parte.
+ ID **del costrutto: l'ID** fornito come secondo argomento durante l'istanziazione del costrutto.
+ **Hash unico**: il AWS CDK genera un hash univoco di 8 caratteri utilizzando un algoritmo di hashing deterministico. Questo hash unico aiuta a garantire che i valori degli ID logici nel modello siano unici l'uno dall'altro. Il comportamento deterministico di questa generazione di hash assicura che il valore dell'ID logico generato per ogni costrutto rimanga lo stesso ogni volta che si esegue la sintesi. Il valore hash cambierà solo se modifichi valori di costrutto specifici come l'ID del costrutto o il suo percorso.
IDs I logici hanno una lunghezza massima di 255 caratteri. Pertanto, il AWS CDK troncherà il percorso di costruzione e l'ID del costrutto, se necessario, per rispettare tale limite.
Di seguito è riportato un esempio di costrutto che definisce un bucket Amazon Simple Storage Service (Amazon S3). Qui, passiamo `myBucket` come ID per il nostro costrutto:
**Example**
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import { Construct} from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';
export class MyCdkAppStack extends cdk.Stack {
constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the S3 bucket
new s3.Bucket(this, 'myBucket', {
versioned: true,
removalPolicy: cdk.RemovalPolicy.DESTROY,
});
}
}
```
------
#### [ JavaScript ]
```
const cdk = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');
class MyCdkAppStack extends cdk.Stack {
constructor(scope, id, props) {
super(scope, id, props);
new s3.Bucket(this, 'myBucket', {
versioned: true,
removalPolicy: cdk.RemovalPolicy.DESTROY,
});
}
}
module.exports = { MyCdkAppStack }
```
------
#### [ Python ]
```
import aws_cdk as cdk
from constructs import Construct
from aws_cdk import Stack
from aws_cdk import aws_s3 as s3
class MyCdkAppStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) - None:
super().__init__(scope, construct_id, **kwargs)
s3.Bucket(self, 'MyBucket',
versioned=True,
removal_policy=cdk.RemovalPolicy.DESTROY
)
```
------
#### [ Java ]
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketProps;
import software.amazon.awscdk.RemovalPolicy;
public class MyCdkAppStack extends Stack {
public MyCdkAppStack(final Construct scope, final String id) {
this(scope, id, null);
}
public MyCdkAppStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
Bucket.Builder.create(this, "myBucket")
.versioned(true)
.removalPolicy(RemovalPolicy.DESTROY)
.build();
}
}
```
------
#### [ C\$1 ]
```
using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.S3;
namespace MyCdkApp
{
public class MyCdkAppStack : Stack
{
public MyCdkAppStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
new Bucket(this, "myBucket", new BucketProps
{
Versioned = true,
RemovalPolicy = RemovalPolicy.DESTROY
});
}
}
}
```
------
#### [ Go ]
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/aws-cdk-go/awscdk/v2/awss3"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
type MyCdkAppStackProps struct {
awscdk.StackProps
}
func NewMyCdkAppStack(scope constructs.Construct, id string, props *MyCdkAppStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, id, sprops)
awss3.NewBucket(stack, jsii.String("myBucket"), awss3.BucketProps{
Versioned: jsii.Bool(true),
RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
})
return stack
}
// ...
```
------
Quando eseguiamo`cdk synth`, `myBucketunique-hash` viene generato un ID logico nel formato di. Di seguito è riportato un esempio di questa risorsa nel AWS CloudFormation modello generato:
```
Resources:
myBucket5AF9C99B:
Type: AWS::S3::Bucket
Properties:
VersioningConfiguration:
Status: Enabled
UpdateReplacePolicy: Delete
DeletionPolicy: Delete
Metadata:
aws:cdk:path: S3BucketAppStack/myBucket/Resource
```
Di seguito è riportato un esempio di costrutto personalizzato denominato `Bar` che definisce un bucket Amazon S3. Il `Bar` costrutto include il costrutto `Foo` personalizzato nel suo percorso:
**Example**
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';
// Define the Bar construct
export class Bar extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
// Define an S3 bucket inside of Bar
new s3.Bucket(this, 'Bucket', {
versioned: true,
removalPolicy: cdk.RemovalPolicy.DESTROY,
} );
}
}
// Define the Foo construct
export class Foo extends Construct {
constructor(scope: Construct, id: string) {
super(scope, id);
// Create an instance of Bar inside Foo
new Bar(this, 'Bar');
}
}
// Define the CDK stack
export class MyCustomAppStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Instantiate Foo construct in the stack
new Foo(this, 'Foo');
}
}
```
------
#### [ JavaScript ]
```
const cdk = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');
const { Construct } = require('constructs');
// Define the Bar construct
class Bar extends Construct {
constructor(scope, id) {
super(scope, id);
// Define an S3 bucket inside of Bar
new s3.Bucket(this, 'Bucket', {
versioned: true,
removalPolicy: cdk.RemovalPolicy.DESTROY,
});
}
}
// Define the Foo construct
class Foo extends Construct {
constructor(scope, id) {
super(scope, id);
// Create an instance of Bar inside Foo
new Bar(this, 'Bar');
}
}
// Define the CDK stack
class MyCustomAppStack extends cdk.Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Instantiate Foo construct in the stack
new Foo(this, 'Foo');
}
}
module.exports = { MyCustomAppStack }
```
------
#### [ Python ]
```
import aws_cdk as cdk
from constructs import Construct
from aws_cdk import (
Stack,
aws_s3 as s3,
RemovalPolicy,
)
# Define the Bar construct
class Bar(Construct):
def __init__(self, scope: Construct, id: str) - None:
super().__init__(scope, id)
# Define an S3 bucket inside of Bar
s3.Bucket(self, 'Bucket',
versioned=True,
removal_policy=RemovalPolicy.DESTROY
)
# Define the Foo construct
class Foo(Construct):
def __init__(self, scope: Construct, id: str) - None:
super().__init__(scope, id)
# Create an instance of Bar inside Foo
Bar(self, 'Bar')
# Define the CDK stack
class MyCustomAppStack(Stack):
def __init__(self, scope: Construct, id: str, **kwargs) - None:
super().__init__(scope, id, **kwargs)
# Instantiate Foo construct in the stack
Foo(self, 'Foo')
```
------
#### [ Java ]
In `my-custom-app/src/main/java/com/myorg/Bar.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.BucketProps;
import software.amazon.awscdk.RemovalPolicy;
public class Bar extends Construct {
public Bar(final Construct scope, final String id) {
super(scope, id);
// Define an S3 bucket inside Bar
Bucket.Builder.create(this, "Bucket")
.versioned(true)
.removalPolicy(RemovalPolicy.DESTROY)
.build();
}
}
```
In `my-custom-app/src/main/java/com/myorg/Foo.java`:
```
package com.myorg;
import software.constructs.Construct;
public class Foo extends Construct {
public Foo(final Construct scope, final String id) {
super(scope, id);
// Create an instance of Bar inside Foo
new Bar(this, "Bar");
}
}
```
In `my-custom-app/src/main/java/com/myorg/MyCustomAppStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
public class MyCustomAppStack extends Stack {
public MyCustomAppStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Instantiate Foo construct in the stack
new Foo(this, "Foo");
}
// Overload constructor in case StackProps is not provided
public MyCustomAppStack(final Construct scope, final String id) {
this(scope, id, null);
}
}
```
------
#### [ C\$1 ]
```
using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.S3;
namespace MyCustomApp
{
// Define the Bar construct
public class Bar : Construct
{
public Bar(Construct scope, string id) : base(scope, id)
{
// Define an S3 bucket inside Bar
new Bucket(this, "Bucket", new BucketProps
{
Versioned = true,
RemovalPolicy = RemovalPolicy.DESTROY
});
}
}
// Define the Foo construct
public class Foo : Construct
{
public Foo(Construct scope, string id) : base(scope, id)
{
// Create an instance of Bar inside Foo
new Bar(this, "Bar");
}
}
// Define the CDK Stack
public class MyCustomAppStack : Stack
{
public MyCustomAppStack(Construct scope, string id, StackProps props = null) : base(scope, id, props)
{
// Instantiate Foo construct in the stack
new Foo(this, "Foo");
}
}
}
```
------
#### [ Go ]
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/aws-cdk-go/awscdk/v2/awss3"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// Define the Bar construct
type Bar struct {
constructs.Construct
}
func NewBar(scope constructs.Construct, id string) constructs.Construct {
bar := constructs.NewConstruct(scope, id)
// Define an S3 bucket inside Bar
awss3.NewBucket(bar, jsii.String("Bucket"), awss3.BucketProps{
Versioned: jsii.Bool(true),
RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
})
return bar
}
// Define the Foo construct
type Foo struct {
constructs.Construct
}
func NewFoo(scope constructs.Construct, id string) constructs.Construct {
foo := constructs.NewConstruct(scope, id)
// Create an instance of Bar inside Foo
NewBar(foo, "Bar")
return foo
}
// Define the CDK Stack
type MyCustomAppStackProps struct {
awscdk.StackProps
}
func NewMyCustomAppStack(scope constructs.Construct, id string, props *MyCustomAppStackProps) awscdk.Stack {
stack := awscdk.NewStack(scope, id, props.StackProps)
// Instantiate Foo construct in the stack
NewFoo(stack, "Foo")
return stack
}
// Define the CDK App
func main() {
app := awscdk.NewApp(nil)
NewMyCustomAppStack(app, "MyCustomAppStack", MyCustomAppStackProps{
StackProps: awscdk.StackProps{},
})
app.Synth(nil)
}
```
------
Quando eseguiamo`cdk synth`, `FooBarBucketunique-hash` viene generato un ID logico nel formato di. Di seguito è riportato un esempio di questa risorsa nel AWS CloudFormation modello generato:
```
Resources:
FooBarBucketBA3ED1FA:
Type: AWS::S3::Bucket
Properties:
VersioningConfiguration:
Status: Enabled
UpdateReplacePolicy: Delete
DeletionPolicy: Delete
# ...
```
## Personalizza la sintesi dello stack CDK
Se il comportamento di sintesi CDK predefinito non soddisfa le tue esigenze, puoi personalizzare la sintesi CDK. Per fare ciò, modificate`DefaultStackSynthesizer`, utilizzate altri sintetizzatori incorporati disponibili o create il vostro sintetizzatore. Per istruzioni, consulta [Personalizzare](customize-synth.md) la sintesi dello stack CDK.
# Personalizza la sintesi dello stack CDK
Puoi personalizzare la sintesi dello stack AWS Cloud Development Kit (AWS CDK) modificando il sintetizzatore predefinito, utilizzando altri sintetizzatori integrati disponibili o creando il tuo sintetizzatore.
Il AWS CDK include i seguenti sintetizzatori integrati che puoi usare per personalizzare il comportamento di sintesi:
+ [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html)— Se non si specifica un sintetizzatore, questo viene utilizzato automaticamente. [Supporta distribuzioni e distribuzioni tra account utilizzando il costrutto CDK Pipelines.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.pipelines-readme.html) Il contratto bootstrap richiede un bucket Amazon S3 esistente con un nome noto, un repository Amazon ECR esistente con un nome noto e cinque ruoli IAM esistenti con nomi noti. Il modello di bootstrap predefinito soddisfa questi requisiti.
+ [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizer.html)— Il contratto bootstrap di questo sintetizzatore richiede un bucket Amazon S3 esistente e un repository Amazon ECR esistente. Non richiede alcun ruolo IAM. Per eseguire le distribuzioni, questo sintetizzatore si basa sulle autorizzazioni dell'utente CDK CLI ed è consigliato alle organizzazioni che desiderano limitare le credenziali di distribuzione IAM. Questo sintetizzatore non supporta distribuzioni tra account o CDK Pipelines.
+ [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.LegacyStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.LegacyStackSynthesizer.html)— Questo sintetizzatore emula il comportamento di sintesi CDK v1. Il suo contratto bootstrap richiede un bucket Amazon S3 esistente con un nome arbitrario e prevede che le posizioni degli asset vengano passate come parametri dello stack. CloudFormation Se si utilizza questo sintetizzatore, è necessario utilizzare la CLI CDK per eseguire la distribuzione.
[Se nessuno di questi sintetizzatori integrati è adatto al vostro caso d'uso, potete scrivere il vostro sintetizzatore come classe che `IStackSynthesizer` implementa o utilizza i sintetizzatori di Construct Hub.](https://constructs.dev/search?q=synthesizer&cdk=aws-cdk)
## Personalizzazione di `DefaultStackSynthesizer`
È il sintetizzatore predefinito per il CDK. `DefaultStackSynthesizer` AWS È progettato per consentire l'implementazione di applicazioni CDK su più account, nonché la distribuzione di app CDK da un sistema CI/CD che non supporta esplicitamente il CDK, ma supporta distribuzioni regolari, come. AWS CloudFormation AWS CodePipeline Questo sintetizzatore è l'opzione migliore per la maggior parte dei casi d'uso.
### `DefaultStackSynthesizer`contratto bootstrap
`DefaultStackSynthesizer`richiede il seguente contratto bootstrap. Queste sono le risorse che devono essere create durante il bootstrap:
| Risorsa Bootstrap | Descrizione | Nome predefinito della risorsa prevista | Scopo |
| --- | --- | --- | --- |
| Bucket Amazon S3 | Secchio di staging | cdk-hnb659fds-assets- - | Memorizza le risorse dei file. |
| Repository Amazon ECR | Archivio di staging | cdk-hnb659 fds-container-assets - - | Archivia e gestisce le risorse di immagini Docker. |
| Ruolo IAM | Implementa il ruolo | cdk-hnb659 - - fds-deploy-role | Presupposto dalla CLI CDK e CodePipeline potenzialmente per assumere altri ruoli e avviare AWS CloudFormation la distribuzione. La politica di fiducia di questo ruolo controlla chi può eseguire l'implementazione con AWS CDK in questo ambiente. AWS |
| Ruolo IAM | AWS CloudFormation ruolo di esecuzione | cdk-hnb659 - - fds-cfn-exec-role | Questo ruolo viene utilizzato da AWS CloudFormation per eseguire la distribuzione. Le politiche di questo ruolo controllano le operazioni che la distribuzione CDK può eseguire. |
| Ruolo IAM | Ruolo di ricerca | cdk-hnb659 - - fds-lookup-role | Questo ruolo viene utilizzato quando la CLI CDK deve eseguire ricerche nel contesto ambientale. La politica di fiducia di questo ruolo controlla chi può cercare informazioni nell'ambiente. |
| Ruolo IAM | Ruolo di pubblicazione di file | cdk-hnb659 - - fds-file-publishing-role | Questo ruolo viene utilizzato per caricare risorse nel bucket di staging di Amazon S3. Viene assunto dal ruolo di distribuzione. |
| Ruolo IAM | Ruolo di pubblicazione di immagini | cdk-hnb659 - - fds-image-publishing-role | Questo ruolo viene utilizzato per caricare immagini Docker nello staging repository di Amazon ECR. Viene assunto dal ruolo di implementazione. |
| Parametro SSM | Parametro della versione Bootstrap | /cdk-bootstrap/hnb659fds/ | La versione del modello bootstrap. Viene utilizzato dal modello bootstrap e dalla CLI CDK per convalidare i requisiti. |
Un modo per personalizzare la sintesi dello stack CDK consiste nel modificare il. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizer.html) Puoi personalizzare questo sintetizzatore per un singolo stack CDK utilizzando la proprietà della tua istanza. `synthesizer` `Stack` Puoi anche modificare tutti `DefaultStackSynthesizer` gli stack nell'app CDK utilizzando la proprietà dell'istanza. `defaultStackSynthesizer` `App`
### Cambia il qualificatore
Il *qualificatore* viene aggiunto al nome delle risorse create durante il bootstrap. Di default, il valore è `hnb659fds`. Quando modificate il qualificatore durante il bootstrap, dovete personalizzare la sintesi dello stack CDK per utilizzare lo stesso qualificatore.
Per modificare il qualificatore, configurate la `qualifier` proprietà `DefaultStackSynthesizer` o configurate il qualificatore come chiave di contesto nel file del progetto CDK. `cdk.json`
Di seguito è riportato un esempio di configurazione della proprietà di: `qualifier` `DefaultStackSynthesizer`
**Example**
```
new MyStack(this, 'MyStack', {
synthesizer: new DefaultStackSynthesizer({
qualifier: 'MYQUALIFIER',
}),
});
```
```
new MyStack(this, 'MyStack', {
synthesizer: new DefaultStackSynthesizer({
qualifier: 'MYQUALIFIER',
}),
})
```
```
MyStack(self, "MyStack",
synthesizer=DefaultStackSynthesizer(
qualifier="MYQUALIFIER"
))
```
```
new MyStack(app, "MyStack", StackProps.builder()
.synthesizer(DefaultStackSynthesizer.Builder.create()
.qualifier("MYQUALIFIER")
.build())
.build();
)
```
```
new MyStack(app, "MyStack", new StackProps
{
Synthesizer = new DefaultStackSynthesizer(new DefaultStackSynthesizerProps
{
Qualifier = "MYQUALIFIER"
})
});
```
```
func NewMyStack(scope constructs.Construct, id string, props *MyStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
synth := awscdk.NewDefaultStackSynthesizer(&awscdk.DefaultStackSynthesizerProps{
Qualifier: jsii.String("MYQUALIFIER"),
})
stack.SetSynthesizer(synth)
return stack
}
```
Di seguito è riportato un esempio di configurazione del qualificatore come chiave di contesto in: `cdk.json`
```
{
"app": "...",
"context": {
"@aws-cdk/core:bootstrapQualifier": "MYQUALIFIER"
}
}
```
### Modificare i nomi delle risorse
Tutte le altre `DefaultStackSynthesizer` proprietà si riferiscono ai nomi delle risorse nel modello di bootstrap. È necessario fornire una di queste proprietà solo se si è modificato il modello di bootstrap e si sono modificati i nomi delle risorse o lo schema di denominazione.
Tutte le proprietà accettano i segnaposto speciali`${Qualifier}`,, e`${AWS::Partition}`. `${AWS::AccountId}` `${AWS::Region}` Questi segnaposto vengono sostituiti rispettivamente dai valori del `qualifier` parametro e dai valori di AWS partizione, ID account e AWS regione per l'ambiente dello stack.
L'esempio seguente mostra le proprietà più comunemente utilizzate `DefaultStackSynthesizer` insieme ai relativi valori predefiniti, come se si stesse istanziando il sintetizzatore. Per un elenco completo, consulta: [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizerProps.html#properties](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.DefaultStackSynthesizerProps.html#properties)
**Example**
```
new DefaultStackSynthesizer({
// Name of the S3 bucket for file assets
fileAssetsBucketName: 'cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}',
bucketPrefix: '',
// Name of the ECR repository for Docker image assets
imageAssetsRepositoryName: 'cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}',
dockerTagPrefix: '',
// ARN of the role assumed by the CLI and Pipeline to deploy here
deployRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}',
deployRoleExternalId: '',
// ARN of the role used for file asset publishing (assumed from the CLI role)
fileAssetPublishingRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region}',
fileAssetPublishingExternalId: '',
// ARN of the role used for Docker asset publishing (assumed from the CLI role)
imageAssetPublishingRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region}',
imageAssetPublishingExternalId: '',
// ARN of the role passed to CloudFormation to execute the deployments
cloudFormationExecutionRole: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}',
// ARN of the role used to look up context information in an environment
lookupRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}',
lookupRoleExternalId: '',
// Name of the SSM parameter which describes the bootstrap stack version number
bootstrapStackVersionSsmParameter: '/cdk-bootstrap/${Qualifier}/version',
// Add a rule to every template which verifies the required bootstrap stack version
generateBootstrapVersionRule: true,
})
```
```
new DefaultStackSynthesizer({
// Name of the S3 bucket for file assets
fileAssetsBucketName: 'cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}',
bucketPrefix: '',
// Name of the ECR repository for Docker image assets
imageAssetsRepositoryName: 'cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}',
dockerTagPrefix: '',
// ARN of the role assumed by the CLI and Pipeline to deploy here
deployRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}',
deployRoleExternalId: '',
// ARN of the role used for file asset publishing (assumed from the CLI role)
fileAssetPublishingRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region}',
fileAssetPublishingExternalId: '',
// ARN of the role used for Docker asset publishing (assumed from the CLI role)
imageAssetPublishingRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region}',
imageAssetPublishingExternalId: '',
// ARN of the role passed to CloudFormation to execute the deployments
cloudFormationExecutionRole: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}',
// ARN of the role used to look up context information in an environment
lookupRoleArn: 'arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}',
lookupRoleExternalId: '',
// Name of the SSM parameter which describes the bootstrap stack version number
bootstrapStackVersionSsmParameter: '/cdk-bootstrap/${Qualifier}/version',
// Add a rule to every template which verifies the required bootstrap stack version
generateBootstrapVersionRule: true,
})
```
```
DefaultStackSynthesizer(
# Name of the S3 bucket for file assets
file_assets_bucket_name="cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}",
bucket_prefix="",
# Name of the ECR repository for Docker image assets
image_assets_repository_name="cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}",
docker_tag_prefix="",
# ARN of the role assumed by the CLI and Pipeline to deploy here
deploy_role_arn="arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}",
deploy_role_external_id="",
# ARN of the role used for file asset publishing (assumed from the CLI role)
file_asset_publishing_role_arn="arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region}",
file_asset_publishing_external_id="",
# ARN of the role used for Docker asset publishing (assumed from the CLI role)
image_asset_publishing_role_arn="arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region}",
image_asset_publishing_external_id="",
# ARN of the role passed to CloudFormation to execute the deployments
cloud_formation_execution_role="arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}",
# ARN of the role used to look up context information in an environment
lookup_role_arn="arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}",
lookup_role_external_id="",
# Name of the SSM parameter which describes the bootstrap stack version number
bootstrap_stack_version_ssm_parameter="/cdk-bootstrap/${Qualifier}/version",
# Add a rule to every template which verifies the required bootstrap stack version
generate_bootstrap_version_rule=True,
)
```
```
DefaultStackSynthesizer.Builder.create()
// Name of the S3 bucket for file assets
.fileAssetsBucketName("cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}")
.bucketPrefix('')
// Name of the ECR repository for Docker image assets
.imageAssetsRepositoryName("cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}")
.dockerTagPrefix('')
// ARN of the role assumed by the CLI and Pipeline to deploy here
.deployRoleArn("arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}")
.deployRoleExternalId("")
// ARN of the role used for file asset publishing (assumed from the CLI role)
.fileAssetPublishingRoleArn("arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region}")
.fileAssetPublishingExternalId("")
// ARN of the role used for Docker asset publishing (assumed from the CLI role)
.imageAssetPublishingRoleArn("arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region}")
.imageAssetPublishingExternalId("")
// ARN of the role passed to CloudFormation to execute the deployments
.cloudFormationExecutionRole("arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}")
.lookupRoleArn("arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}")
.lookupRoleExternalId("")
// Name of the SSM parameter which describes the bootstrap stack version number
.bootstrapStackVersionSsmParameter("/cdk-bootstrap/${Qualifier}/version")
// Add a rule to every template which verifies the required bootstrap stack version
.generateBootstrapVersionRule(true)
.build()
```
```
new DefaultStackSynthesizer(new DefaultStackSynthesizerProps
{
// Name of the S3 bucket for file assets
FileAssetsBucketName = "cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}",
BucketPrefix = "",
// Name of the ECR repository for Docker image assets
ImageAssetsRepositoryName = "cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}",
DockerTagPrefix = "",
// ARN of the role assumed by the CLI and Pipeline to deploy here
DeployRoleArn = "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-deploy-role-${AWS::AccountId}-${AWS::Region}",
DeployRoleExternalId = "",
// ARN of the role used for file asset publishing (assumed from the CLI role)
FileAssetPublishingRoleArn = "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-file-publishing-role-${AWS::AccountId}-${AWS::Region}",
FileAssetPublishingExternalId = "",
// ARN of the role used for Docker asset publishing (assumed from the CLI role)
ImageAssetPublishingRoleArn = "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-image-publishing-role-${AWS::AccountId}-${AWS::Region}",
ImageAssetPublishingExternalId = "",
// ARN of the role passed to CloudFormation to execute the deployments
CloudFormationExecutionRole = "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-cfn-exec-role-${AWS::AccountId}-${AWS::Region}",
LookupRoleArn = "arn:${AWS::Partition}:iam::${AWS::AccountId}:role/cdk-${Qualifier}-lookup-role-${AWS::AccountId}-${AWS::Region}",
LookupRoleExternalId = "",
// Name of the SSM parameter which describes the bootstrap stack version number
BootstrapStackVersionSsmParameter = "/cdk-bootstrap/${Qualifier}/version",
// Add a rule to every template which verifies the required bootstrap stack version
GenerateBootstrapVersionRule = true,
})
```
## Utilizzare `CliCredentialsStackSynthesizer`
Per modificare le credenziali di sicurezza utilizzate per fornire le autorizzazioni durante le distribuzioni CDK, è possibile personalizzare la sintesi utilizzando. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizer.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizer.html) Questo sintetizzatore funziona con AWS le risorse predefinite create durante il bootstrap per archiviare le risorse, come il bucket Amazon S3 e il repository Amazon ECR. Invece di utilizzare i ruoli IAM predefiniti creati dal CDK durante il bootstrap, utilizza le credenziali di sicurezza dell'attore che avvia la distribuzione. Pertanto, le credenziali di sicurezza dell'attore devono disporre di autorizzazioni valide per eseguire tutte le azioni di distribuzione. Il diagramma seguente illustra il processo di distribuzione quando si utilizza questo sintetizzatore:
![\[Processo di distribuzione utilizzando. CLICredentials StackSynthesizer\]](http://docs.aws.amazon.com/it_it/cdk/v2/guide/images/CliCredentialsStackSynthesizer-deploy-process_cdk_flowchart.png)
Quando si utilizza`CliCredentialsStackSynthesizer`:
+ Per impostazione predefinita, CloudFormation esegue chiamate API nel tuo account utilizzando le autorizzazioni dell'attore. Pertanto, l'identità corrente deve disporre dell'autorizzazione per apportare le modifiche necessarie alle AWS risorse dello CloudFormation stack, oltre alle autorizzazioni per eseguire le CloudFormation operazioni necessarie, ad esempio o. `CreateStack` `UpdateStack` Le funzionalità di distribuzione saranno limitate alle autorizzazioni dell'attore.
+ La pubblicazione e la CloudFormation distribuzione delle risorse verranno eseguite utilizzando l'attuale identità IAM. Questa identità deve disporre di autorizzazioni sufficienti sia per la lettura che per la scrittura nell'asset bucket e nell'archivio.
+ Le ricerche vengono eseguite utilizzando l'identità IAM corrente e le ricerche sono soggette alle relative politiche.
Quando si utilizza questo sintetizzatore, è possibile utilizzare un ruolo di CloudFormation esecuzione separato specificandolo utilizzando l'[`--role-arn`](ref-cli-cmd.md#ref-cli-cmd-options-role-arn)opzione con qualsiasi comando CDK CLI.
### `CliCredentialsStackSynthesizer`contratto bootstrap
`CliCredentialsStackSynthesizer`richiede il seguente contratto bootstrap. Queste sono le risorse che devono essere create durante il bootstrap:
| Risorsa Bootstrap | Descrizione | Nome predefinito della risorsa prevista | Scopo |
| --- | --- | --- | --- |
| Bucket Amazon S3 | Secchio di staging | cdk-hnb659fds-assets- - | Memorizza le risorse dei file. |
| Repository Amazon ECR | Archivio di staging | cdk-hnb659 fds-container-assets - - | Archivia e gestisce le risorse di immagini Docker. |
La stringa `hnb659fds` nel nome della risorsa è chiamata *qualificatore*. Il suo valore predefinito non ha alcun significato particolare. È possibile avere più copie delle risorse di bootstrap in un unico ambiente purché abbiano un qualificatore diverso. Avere più copie può essere utile per tenere separate le risorse di diverse applicazioni nello stesso ambiente.
È possibile implementare il modello di bootstrap predefinito per soddisfare il contratto `CliCredentialsStackSynthesizer` bootstrap. Il modello di bootstrap predefinito creerà i ruoli IAM, ma questo sintetizzatore non li utilizzerà. Puoi anche personalizzare il modello di bootstrap per rimuovere i ruoli IAM.
### Modificare le `CliCredentialsStackSynthesizer`
Se modifichi il qualificatore o uno qualsiasi dei nomi di risorse bootstrap predefiniti durante il bootstrap, devi modificare il sintetizzatore in modo che utilizzi gli stessi nomi. Puoi modificare il sintetizzatore per un singolo stack o per tutti gli stack dell'app. Di seguito è riportato un esempio:
**Example**
```
new MyStack(this, 'MyStack', {
synthesizer: new CliCredentialsStackSynthesizer({
qualifier: 'MYQUALIFIER',
}),
});
```
```
new MyStack(this, 'MyStack', {
synthesizer: new CliCredentialsStackSynthesizer({
qualifier: 'MYQUALIFIER',
}),
})
```
```
MyStack(self, "MyStack",
synthesizer=CliCredentialsStackSynthesizer(
qualifier="MYQUALIFIER"
))
```
```
new MyStack(app, "MyStack", StackProps.builder()
.synthesizer(CliCredentialsStackSynthesizer.Builder.create()
.qualifier("MYQUALIFIER")
.build())
.build();
)
```
```
new MyStack(app, "MyStack", new StackProps
{
Synthesizer = new CliCredentialsStackSynthesizer(new CliCredentialsStackSynthesizerProps
{
Qualifier = "MYQUALIFIER"
})
});
```
L'esempio seguente mostra le proprietà più comunemente utilizzate per `CliCredentialsStackSynthesizer` insieme ai relativi valori predefiniti. Per un elenco completo, vedere [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizerProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CliCredentialsStackSynthesizerProps.html):
**Example**
```
new CliCredentialsStackSynthesizer({
// Value for '${Qualifier}' in the resource names
qualifier: 'hnb659fds',
// Name of the S3 bucket for file assets
fileAssetsBucketName: 'cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}',
bucketPrefix: '',
// Name of the ECR repository for Docker image assets
imageAssetsRepositoryName: 'cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}',
dockerTagPrefix: '',
})
```
```
new CliCredentialsStackSynthesizer({
// Value for '${Qualifier}' in the resource names
qualifier: 'hnb659fds',
// Name of the S3 bucket for file assets
fileAssetsBucketName: 'cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}',
bucketPrefix: '',
// Name of the ECR repository for Docker image assets
imageAssetsRepositoryName: 'cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}',
dockerTagPrefix: '',
})
```
```
CliCredentialsStackSynthesizer(
# Value for '${Qualifier}' in the resource names
qualifier="hnb659fds",
# Name of the S3 bucket for file assets
file_assets_bucket_name="cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}",
bucket_prefix="",
# Name of the ECR repository for Docker image assets
image_assets_repository_name="cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}",
docker_tag_prefix="",
)
```
```
CliCredentialsStackSynthesizer.Builder.create()
// Value for '${Qualifier}' in the resource names
.qualifier("hnb659fds")
// Name of the S3 bucket for file assets
.fileAssetsBucketName("cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}")
.bucketPrefix('')
// Name of the ECR repository for Docker image assets
.imageAssetsRepositoryName("cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}")
.dockerTagPrefix('')
.build()
```
```
new CliCredentialsStackSynthesizer(new CliCredentialsStackSynthesizerProps
{
// Value for '${Qualifier}' in the resource names
Qualifier = "hnb659fds",
// Name of the S3 bucket for file assets
FileAssetsBucketName = "cdk-${Qualifier}-assets-${AWS::AccountId}-${AWS::Region}",
BucketPrefix = "",
// Name of the ECR repository for Docker image assets
ImageAssetsRepositoryName = "cdk-${Qualifier}-container-assets-${AWS::AccountId}-${AWS::Region}",
DockerTagPrefix = "",
})
```
## Utilizzare `LegacyStackSynthesizer`
`LegacyStackSynthesizer`Emula il comportamento delle distribuzioni CDK v1. Le credenziali di sicurezza dell'attore che esegue la distribuzione verranno utilizzate per stabilire le autorizzazioni. Le risorse dei file verranno caricate in un bucket che deve essere creato utilizzando uno AWS CloudFormation stack denominato. `CDKToolkit` La CLI CDK creerà un repository Amazon ECR non gestito `aws-cdk/assets` denominato per archiviare le risorse di immagini Docker. Sarai responsabile della pulizia e della gestione di questo repository. Gli stack sintetizzati utilizzando `LegacyStackSynthesizer` possono essere distribuiti solo utilizzando la CLI CDK.
Puoi utilizzarlo `LegacyStackSynthesizer` se stai migrando da CDK v1 a CDK v2 e non riesci a riavviare i tuoi ambienti. Per i nuovi progetti, si consiglia di non utilizzarlo. `LegacyStackSynthesizer`
### `LegacyStackSynthesizer`contratto bootstrap
`LegacyStackSynthesizer`richiede il seguente contratto bootstrap. Queste sono le risorse che devono essere create durante il bootstrap:
| Risorsa Bootstrap | Descrizione | Nome predefinito della risorsa prevista | Scopo |
| --- | --- | --- | --- |
| Bucket Amazon S3 | Secchio di staging | cdk-hnb659fds-assets- - | Memorizza le risorse dei file. |
| CloudFormation uscita | Uscita del nome del bucket | Pila — `CDKToolkit` Nome dell'output — `BucketName` | Un CloudFormation output che descrive il nome del bucket di staging |
`LegacyStackSynthesizer`Non presuppone l'esistenza di un bucket Amazon S3 con un nome fisso. Invece, il CloudFormation modello sintetizzato conterrà tre CloudFormation parametri per ogni asset di file. Questi parametri memorizzeranno il nome del bucket Amazon S3, la chiave dell'oggetto Amazon S3 e l'hash degli artefatti per ogni asset di file.
Docker le risorse di immagini verranno pubblicate in un repository Amazon ECR denominato. `aws-cdk/assets` Questo nome può essere modificato per risorsa. I repository verranno creati se non esistono.
Deve esistere uno CloudFormation stack con il nome predefinito. `CDKToolkit` Questo stack deve avere un nome di CloudFormation esportazione `BucketName` che si riferisca allo staging bucket.
Il modello di bootstrap predefinito soddisfa il contratto bootstrap. `LegacyStackSynthesizer` Tuttavia, verrà utilizzato solo il bucket Amazon S3 contenuto nelle risorse di bootstrap del modello di bootstrap. Puoi personalizzare il modello di bootstrap per rimuovere le risorse di bootstrap di Amazon ECR, IAM e SSM.
### `LegacyStackSynthesizer`processo di distribuzione
Quando si utilizza questo sintetizzatore, durante la distribuzione viene eseguito il seguente processo:
+ Il CDK CLI cerca uno CloudFormation stack denominato `CDKToolkit` nel tuo ambiente. Da questo stack, il CDK CLI legge l'output denominato. CloudFormation `BucketName` È possibile utilizzare l'`--toolkit-stack-name`opzione con `cdk deploy` per specificare un nome di pila diverso.
+ Le credenziali di sicurezza dell'attore che avvia la distribuzione verranno utilizzate per stabilire le autorizzazioni per la distribuzione. Pertanto, l'attore deve disporre di autorizzazioni sufficienti per eseguire tutte le azioni di distribuzione. Ciò include la lettura e la scrittura nel bucket di staging Amazon S3, la creazione e la scrittura nel repository Amazon ECR, l'avvio e il monitoraggio delle AWS CloudFormation distribuzioni e l'esecuzione di tutte le chiamate API necessarie per la distribuzione.
+ Se necessario e se le autorizzazioni sono valide, gli asset di file verranno pubblicati nel bucket di staging di Amazon S3.
+ Se necessario e se le autorizzazioni sono valide, Docker le risorse di immagini vengono pubblicate nell'archivio denominato dalla `repositoryName` proprietà della risorsa. Il valore predefinito è `'aws-cdk/assets'` se non fornite un nome per il repository.
+ Se le autorizzazioni sono valide, viene eseguita la AWS CloudFormation distribuzione. Le posizioni del bucket di staging e delle chiavi di Amazon S3 vengono passate come parametri. CloudFormation