Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'
InstanceType:
Description: WebServer EC2 instance type
Type: String
Default: t3.micro
AllowedValues:
- t3.nano
- t3.micro
- t3.small
- t3.medium
- t3a.nano
- t3a.micro
- t3a.small
- t3a.medium
- m5.large
- m5.xlarge
- m5.2xlarge
- m5a.large
- m5a.xlarge
- m5a.2xlarge
- c5.large
- c5.xlarge
- c5.2xlarge
- r5.large
- r5.xlarge
- r5.2xlarge
- r5a.large
- r5a.xlarge
- r5a.2xlarge
ConstraintDescription: must be a valid EC2 instance type.
Resources:
WebServerInstance:
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
SecurityGroupIds:
- !Ref WebServerSecurityGroup
UserData:
Fn::Base64: !Sub |
#!/bin/bash -xe
# Get the latest CloudFormation package
yum update -y aws-cfn-bootstrap
# Run cfn-init
/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'
# Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
/opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
# Signal success or failure
/opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
Metadata:
AWS::CloudFormation::Init:
config:
packages:
yum:
httpd: []
php: []
files:
/var/www/html/index.php:
content: |
Hello World!";
?>
mode: '000644'
owner: apache
group: apache
/etc/cfn/cfn-hup.conf:
content: !Sub |
[main]
stack=${AWS::StackId}
region=${AWS::Region}
# The interval used to check for changes to the resource metadata in minutes. Default is 15
interval=2
mode: '000400'
owner: root
group: root
/etc/cfn/hooks.d/cfn-auto-reloader.conf:
content: !Sub |
[cfn-auto-reloader-hook]
triggers=post.update
path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
runas=root
services:
systemd:
httpd:
enabled: true
ensureRunning: true
cfn-hup:
enabled: true
ensureRunning: true
files:
- /etc/cfn/cfn-hup.conf
- /etc/cfn/hooks.d/cfn-auto-reloader.conf
CreationPolicy:
ResourceSignal:
Timeout: PT5M
WebServerSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Enable HTTP access via port 80
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
Outputs:
WebsiteURL:
Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
Description: URL of the web application
```
**Per avviare uno stack da questo modello**
1. Copia il modello e salvalo localmente sul tuo sistema come file di testo. Annotare il percorso perché sarà necessario utilizzare il file in una fase successiva.
1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. Scegli **Crea stack, con nuove risorse** (standard).
1. Scegli **Scegli un modello esistente**.
1. In **Specificare modello**, scegli **Carica un file modello** e vai al file che hai creato nel primo passaggio, quindi scegli **Avanti**.
1. Nella pagina **Specificare i dettagli dello stack**, immettete **UpdateTutorial** come nome dello stack.
1. In **Parametri**, mantieni invariati tutti i parametri e scegli **Avanti** due volte.
1. Nella schermata **Rivedi e crea**, scegli **Invia**.
Dopo che lo stato del tuo stack sarà stato raggiunto`CREATE_COMPLETE`, la scheda **Output** mostrerà l'URL del tuo sito web. Se scegli il valore dell'`WebsiteURL`output, vedrai funzionare la tua nuova applicazione PHP.
## Passaggio 2: aggiorna l'applicazione
Una volta distribuito lo stack, è il momento di aggiornare l'applicazione. Apporteremo una semplice modifica al testo visualizzato dall'applicazione. Per farlo, aggiungeremo un comando echo al file index.php come illustrato in questo frammento di modello:
```
files:
/var/www/html/index.php:
content: |
Hello World!";
echo "This is an updated version of our application.
";
?>
mode: '000644'
owner: apache
group: apache
```
Utilizza un editor di testo per modificare manualmente il file del modello salvato in locale.
Ora aggiorna lo stack.
**Per aggiornare lo stack con il modello aggiornato**
1. Nella CloudFormation console, seleziona il tuo **UpdateTutorial** stack.
1. Scegli **Aggiorna, Effettua un aggiornamento diretto**.
1. Scegli **Sostituisci modello esistente**.
1. In **Specificare modello**, scegli **Carica un file modello** e carica il file modello modificato, quindi scegli **Avanti**.
1. Nella pagina **Specificare i dettagli dello stack**, mantieni invariati tutti i parametri e scegli **Avanti** due volte.
1. Nella pagina **Revisione**, esamina le modifiche. In **Modifiche**, dovresti vedere che CloudFormation aggiornerà la `WebServerInstance` risorsa.
1. Seleziona **Invia**.
Quando lo stack è nello `UPDATE_COMPLETE` stato, puoi scegliere nuovamente il valore `WebsiteURL` di output per verificare che le modifiche all'applicazione abbiano avuto effetto. Il `cfn-hup` demone viene eseguito ogni 2 minuti, quindi potrebbero essere necessari fino a 2 minuti prima che l'applicazione cambi una volta aggiornato lo stack.
Per vedere il set di risorse che sono state aggiornate, vai alla console. CloudFormation Nella scheda **Events (Eventi)** controlla gli eventi dello stack. In questo caso particolare, i metadati per l' EC2 istanza Amazon sono `WebServerInstance` stati aggiornati, il che ha CloudFormation comportato anche una rivalutazione delle altre risorse (`WebServerSecurityGroup`) per garantire che non vi fossero altre modifiche. Nessuna delle altre risorse dello stack è stata modificata. CloudFormation aggiornerà solo le risorse dello stack interessate dalle modifiche allo stack. Tali modifiche possono essere dirette, ad esempio modifiche alle proprietà o ai metadati, oppure possono essere dovute a dipendenze o flussi di dati o ad altre funzioni `Ref` `GetAtt` intrinseche del modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).
Questo semplice aggiornamento illustra il processo. Tuttavia, puoi apportare modifiche molto più complesse ai file e ai pacchetti distribuiti nelle tue EC2 istanze Amazon. Ad esempio, puoi decidere di aggiungere MySQL all'istanza, insieme al supporto PHP per MySQL. A tale scopo, è sufficiente aggiungere gli ulteriori pacchetti e file con eventuali altri servizi alla configurazione e quindi aggiornare lo stack per distribuire le modifiche.
```
packages:
yum:
httpd: []
php: []
mysql: []
php-mysql: []
mysql-server: []
mysql-libs: []
...
services:
systemd:
httpd:
enabled: true
ensureRunning: true
cfn-hup:
enabled: true
ensureRunning: true
files:
- /etc/cfn/cfn-hup.conf
- /etc/cfn/hooks.d/cfn-auto-reloader.conf
mysqld:
enabled: true
ensureRunning: true
```
Puoi aggiornare i CloudFormation metadati per aggiornarli alle nuove versioni dei pacchetti utilizzati dall'applicazione. Negli esempi precedenti, la proprietà version per ogni pacchetto è vuota, a indicare che `cfn-init` deve installare la versione più recente del pacchetto.
```
packages:
yum:
httpd: []
php: []
```
È possibile specificare una stringa di versione per un pacchetto. Se modifichi la stringa della versione nelle successive chiamate di aggiornamento dello stack, verrà distribuita la nuova versione del pacchetto. Ecco un esempio di utilizzo dei numeri di versione per RubyGems i pacchetti. Qualsiasi pacchetto che supporta il controllo delle versioni può avere versioni specifiche.
```
packages:
rubygems:
mysql: []
rubygems-update:
- "1.6.2"
rake:
- "0.8.7"
rails:
- "2.3.11"
```
## Fase 3: Aggiungere l'accesso SSH con una coppia di key pair
Puoi anche aggiornare una risorsa nel modello per aggiungere proprietà che non erano state originariamente specificate nel modello. Per illustrare ciò, aggiungeremo una coppia di EC2 chiavi Amazon a un' EC2istanza esistente e quindi apriremo la porta 22 nel gruppo di EC2 sicurezza Amazon in modo da poter utilizzare Secure Shell (SSH) per accedere all'istanza.
**Per aggiungere l'accesso SSH a un'istanza Amazon EC2 esistente**
1. Aggiungi due parametri aggiuntivi al modello per inserire il nome di una coppia di EC2 chiavi Amazon esistente e di una posizione SSH.
```
Parameters:
KeyName:
Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
Type: AWS::EC2::KeyPair::KeyName
ConstraintDescription: must be the name of an existing EC2 KeyPair.
SSHLocation:
Description: The IP address that can be used to SSH to the EC2 instances in CIDR format (e.g. 203.0.113.1/32)
Type: String
MinLength: 9
MaxLength: 18
Default: 0.0.0.0/0
AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
```
1. Aggiungi la `KeyName` proprietà all' EC2 istanza Amazon.
```
WebServerInstance:
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
KeyName: !Ref KeyName
SecurityGroupIds:
- !Ref WebServerSecurityGroup
```
1. Aggiungi la porta 22 e la posizione SSH alle regole di ingresso per il gruppo di EC2 sicurezza Amazon.
```
WebServerSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: !Ref SSHLocation
```
1. Aggiorna lo stack seguendo gli stessi passaggi spiegati in. [Passaggio 2: aggiorna l'applicazione](#update-stack-update-application)
## Fase 4: Aggiornare il tipo di istanza
Ora dimostriamo come aggiornare l'infrastruttura sottostante modificando il tipo di istanza.
Lo stack che abbiamo creato finora utilizza un'istanza Amazon EC2 t3.micro. Supponiamo che il tuo sito web appena creato stia ricevendo più traffico di quanto possa gestire un'istanza t3.micro e ora desideri passare a un tipo di istanza Amazon m5.large. EC2 Se l'architettura del tipo di istanza cambia, l'istanza deve essere creata con un'AMI diversa. Tuttavia, sia t3.micro che m5.large utilizzano le stesse architetture di CPU ed eseguono Amazon Linux 2 (x86\$164). AMIs Per ulteriori informazioni, consulta la sezione [Compatibilità per la modifica del tipo di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resize-limitations.html) nella *Amazon EC2 User Guide*.
Utilizziamo il modello che abbiamo modificato nel passaggio precedente per cambiare il tipo di istanza. Poiché `InstanceType` era un parametro di input per il modello, non è necessario modificare il modello; possiamo modificare il valore del parametro nella pagina **Specificare i dettagli dello stack**.
**Per aggiornare lo stack con un nuovo valore di parametro**
1. Nella CloudFormation console, seleziona il tuo **UpdateTutorial** stack.
1. Scegli **Aggiorna, Effettua un aggiornamento diretto**.
1. Scegli **Usa modello esistente**, quindi scegli **Avanti**.
1. Nella pagina **Specificare i dettagli dello stack**, modifica il valore della casella di **InstanceType**testo da `t3.micro` a`m5.large`. Quindi, scegli **Avanti** due volte.
1. Nella pagina **Revisione**, esamina le modifiche. In **Modifiche**, dovresti vedere che CloudFormation aggiornerà la `WebServerInstance` risorsa.
1. Seleziona **Invia**.
Puoi modificare dinamicamente il tipo di istanza di un'istanza EC2 Amazon supportata da EBS avviando e arrestando l'istanza. CloudFormation tenta di ottimizzare la modifica aggiornando il tipo di istanza e riavviando l'istanza, in modo che l'ID dell'istanza non cambi. Quando l'istanza viene riavviata, tuttavia, l'indirizzo IP pubblico dell'istanza cambia. Per garantire che l'indirizzo IP elastico sia associato correttamente dopo la modifica, CloudFormation aggiornerà anche l'indirizzo IP elastico. Puoi vedere le modifiche nella CloudFormation console nella scheda **Eventi**.
Per verificare il tipo di istanza da Console di gestione AWS, apri la EC2 console Amazon e individua l'istanza lì.
## Fase 5: Aggiornare l'AMI
Ora aggiorniamo il nostro stack per utilizzare Amazon Linux 2023, che è la prossima generazione di Amazon Linux.
L'aggiornamento dell'AMI è una modifica importante che richiede la sostituzione dell'istanza. Non possiamo semplicemente avviare e fermare l'istanza per modificare l'AMI; la CloudFormation considera una modifica a una proprietà immutabile della risorsa. Per apportare una modifica a una proprietà immutabile, è CloudFormation necessario avviare una risorsa sostitutiva, in questo caso una nuova EC2 istanza Amazon che esegue la nuova AMI.
Diamo un'occhiata a come potremmo aggiornare il nostro modello di stack per utilizzare Amazon Linux 2023. Le modifiche principali includono l'aggiornamento del parametro AMI e il passaggio `yum` da un gestore di `dnf` pacchetti.
```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
LatestAmiId:
Description: The latest Amazon Linux 2023 AMI from the Parameter Store
Type: AWS::SSM::Parameter::Value
Default: '/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64'
InstanceType:
Description: WebServer EC2 instance type
Type: String
Default: t3.micro
AllowedValues:
- t3.nano
- t3.micro
- t3.small
- t3.medium
- t3a.nano
- t3a.micro
- t3a.small
- t3a.medium
- m5.large
- m5.xlarge
- m5.2xlarge
- m5a.large
- m5a.xlarge
- m5a.2xlarge
- c5.large
- c5.xlarge
- c5.2xlarge
- r5.large
- r5.xlarge
- r5.2xlarge
- r5a.large
- r5a.xlarge
- r5a.2xlarge
ConstraintDescription: must be a valid EC2 instance type.
KeyName:
Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
Type: AWS::EC2::KeyPair::KeyName
ConstraintDescription: must be the name of an existing EC2 KeyPair.
SSHLocation:
Description: The IP address that can be used to SSH to the EC2 instances in CIDR format (e.g. 203.0.113.1/32)
Type: String
MinLength: 9
MaxLength: 18
Default: 0.0.0.0/0
AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
Resources:
WebServerInstance:
Type: AWS::EC2::Instance
Properties:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
KeyName: !Ref KeyName
SecurityGroupIds:
- !Ref WebServerSecurityGroup
UserData:
Fn::Base64: !Sub |
#!/bin/bash -xe
# Get the latest CloudFormation package
dnf update -y aws-cfn-bootstrap
# Run cfn-init
/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'
# Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
/opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
# Signal success or failure
/opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
Metadata:
AWS::CloudFormation::Init:
config:
packages:
dnf:
httpd: []
php: []
files:
/var/www/html/index.php:
content: |
Hello World!";
echo "This is an updated version of our application.
";
echo "Running on Amazon Linux 2023!
";
?>
mode: '000644'
owner: apache
group: apache
/etc/cfn/cfn-hup.conf:
content: !Sub |
[main]
stack=${AWS::StackId}
region=${AWS::Region}
# The interval used to check for changes to the resource metadata in minutes. Default is 15
interval=2
mode: '000400'
owner: root
group: root
/etc/cfn/hooks.d/cfn-auto-reloader.conf:
content: !Sub |
[cfn-auto-reloader-hook]
triggers=post.update
path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
runas=root
services:
systemd:
httpd:
enabled: true
ensureRunning: true
cfn-hup:
enabled: true
ensureRunning: true
files:
- /etc/cfn/cfn-hup.conf
- /etc/cfn/hooks.d/cfn-auto-reloader.conf
CreationPolicy:
ResourceSignal:
Timeout: PT5M
WebServerSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: !Ref SSHLocation
Outputs:
WebsiteURL:
Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
Description: URL of the web application
```
Aggiorna lo stack seguendo gli stessi passaggi spiegati in[Passaggio 2: aggiorna l'applicazione](#update-stack-update-application).
Dopo l'esecuzione della nuova istanza, CloudFormation aggiorna le altre risorse dello stack in modo che puntino alla nuova risorsa. Quando tutte le nuove risorse sono state create, la vecchia risorsa viene eliminata, in un processo noto come `UPDATE_CLEANUP`. Questa volta noterai che l'ID istanza e l'URL applicazione dell'istanza nello stack sono cambiati in conseguenza dell'aggiornamento. **Gli eventi nella tabella Eventi contengono una descrizione «L'aggiornamento richiesto comporta una modifica a una proprietà immutabile e quindi crea una nuova risorsa fisica» per indicare che una risorsa è stata sostituita.**
In alternativa: se hai un codice applicativo scritto nell'AMI che desideri aggiornare, puoi utilizzare lo stesso meccanismo di aggiornamento dello stack per aggiornare l'AMI e caricare la tua nuova applicazione.
**Per aggiornare l'AMI con codice applicativo personalizzato**
1. Crea la tua nuova AMI contenente le modifiche all'applicazione o al sistema operativo. *Per ulteriori informazioni, consulta [Creare un'AMI supportata da Amazon EBS nella](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) Amazon User Guide. EC2 *
1. Aggiorna il modello per incorporare il nuovo ID AMI.
1. Aggiorna lo stack seguendo gli stessi passaggi spiegati in[Passaggio 2: aggiorna l'applicazione](#update-stack-update-application).
Quando aggiorni lo stack, CloudFormation rileva che l'ID AMI è cambiato e quindi attiva un aggiornamento dello stack nello stesso modo in cui abbiamo avviato quello precedente.
## Considerazioni su disponibilità e impatto
Diverse proprietà hanno diverso impatto sulle risorse nello stack. È possibile utilizzare CloudFormation per aggiornare qualsiasi proprietà; tuttavia, prima di apportare modifiche, è opportuno considerare le seguenti domande:
1. In che modo l'aggiornamento influisce sulla risorsa stessa? Ad esempio, l'aggiornamento di una soglia di allarme renderà l'allarme inattivo durante l'aggiornamento. Come abbiamo visto, la modifica del tipo di istanza richiede l'arresto e il riavvio dell'istanza. CloudFormation utilizza le azioni di aggiornamento o modifica delle risorse sottostanti per apportare modifiche alle risorse. Per comprendere l'impatto degli aggiornamenti, è necessario verificare la documentazione delle risorse specifiche.
1. La modifica è modificabile o non modificabile? Alcune modifiche alle proprietà delle risorse, come la modifica dell'AMI su un' EC2 istanza Amazon, non sono supportate dai servizi sottostanti. In caso di modifiche modificabili, CloudFormation utilizzerà il tipo Update o Modify APIs per le risorse sottostanti. Per le modifiche immutabili alle proprietà, CloudFormation creerà nuove risorse con le proprietà aggiornate e quindi le collegherà allo stack prima di eliminare le vecchie risorse. Sebbene CloudFormation cerchi di ridurre i tempi di inattività delle risorse dello stack, la sostituzione di una risorsa è un processo in più fasi e richiederà tempo. Durante la riconfigurazione dello stack, l'applicazione non sarà completamente operativa. Ad esempio, potrebbe non essere in grado di servire richieste o accedere a un database.
## Risorse correlate
Per ulteriori informazioni sull'utilizzo CloudFormation per avviare le applicazioni e sull'integrazione con altri servizi di configurazione e distribuzione come Puppet eOpscode Chef, consulta i seguenti white paper:
+ [Avvio delle applicazioni tramite CloudFormation](https://s3.amazonaws.com/cloudformation-examples/BoostrappingApplicationsWithAWSCloudFormation.pdf)
+ [Integrazione con CloudFormation Opscode Chef](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithOpscodeChef.pdf)
+ [Integrazione con CloudFormation Puppet](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithPuppet.pdf)
# Creazione di un'applicazione dimensionata e con carico bilanciato
Per questa procedura dettagliata, viene creato uno stack che aiuta a configurare un'applicazione dimensionata e con carico bilanciato. La procedura guidata fornisce un modello di esempio che potrai usare per creare lo stack. Il modello di esempio prevede un gruppo con dimensionamento automatico, un Application Load Balancer, gruppi di sicurezza che controllano il traffico verso il sistema di bilanciamento del carico e il gruppo con dimensionamento automatico e una configurazione di notifica Amazon SNS per pubblicare notifiche sulle attività di dimensionamento.
Questo modello consente di creare una o più istanze Amazon EC2 e un Application Load Balancer. Se crei uno stack da questo modello, ti verranno addebitate le risorse AWS utilizzate.
## Modello full stack
Cominciamo con il modello.
**YAML**
```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
InstanceType:
Description: The EC2 instance type
Type: String
Default: t3.micro
AllowedValues:
- t3.micro
- t3.small
- t3.medium
KeyName:
Description: Name of an existing EC2 key pair to allow SSH access to the instances
Type: AWS::EC2::KeyPair::KeyName
LatestAmiId:
Description: The latest Amazon Linux 2 AMI from the Parameter Store
Type: AWS::SSM::Parameter::Value
Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'
OperatorEmail:
Description: The email address to notify when there are any scaling activities
Type: String
SSHLocation:
Description: The IP address range that can be used to SSH to the EC2 instances
Type: String
MinLength: 9
MaxLength: 18
Default: 0.0.0.0/0
ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
Subnets:
Type: 'List'
Description: At least two public subnets in different Availability Zones in the selected VPC
VPC:
Type: AWS::EC2::VPC::Id
Description: A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet
Resources:
ELBSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: ELB Security Group
VpcId: !Ref VPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
EC2SecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: EC2 Security Group
VpcId: !Ref VPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
SourceSecurityGroupId:
Fn::GetAtt:
- ELBSecurityGroup
- GroupId
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: !Ref SSHLocation
EC2TargetGroup:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
HealthCheckIntervalSeconds: 30
HealthCheckProtocol: HTTP
HealthCheckTimeoutSeconds: 15
HealthyThresholdCount: 5
Matcher:
HttpCode: '200'
Name: EC2TargetGroup
Port: 80
Protocol: HTTP
TargetGroupAttributes:
- Key: deregistration_delay.timeout_seconds
Value: '20'
UnhealthyThresholdCount: 3
VpcId: !Ref VPC
ALBListener:
Type: AWS::ElasticLoadBalancingV2::Listener
Properties:
DefaultActions:
- Type: forward
TargetGroupArn: !Ref EC2TargetGroup
LoadBalancerArn: !Ref ApplicationLoadBalancer
Port: 80
Protocol: HTTP
ApplicationLoadBalancer:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Scheme: internet-facing
Subnets: !Ref Subnets
SecurityGroups:
- !GetAtt ELBSecurityGroup.GroupId
LaunchTemplate:
Type: AWS::EC2::LaunchTemplate
Properties:
LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
LaunchTemplateData:
ImageId: !Ref LatestAmiId
InstanceType: !Ref InstanceType
KeyName: !Ref KeyName
SecurityGroupIds:
- !Ref EC2SecurityGroup
UserData:
Fn::Base64: !Sub |
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd
echo "Hello World!
" > /var/www/html/index.html
NotificationTopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Endpoint: !Ref OperatorEmail
Protocol: email
WebServerGroup:
Type: AWS::AutoScaling::AutoScalingGroup
Properties:
LaunchTemplate:
LaunchTemplateId: !Ref LaunchTemplate
Version: !GetAtt LaunchTemplate.LatestVersionNumber
MaxSize: '3'
MinSize: '1'
NotificationConfigurations:
- TopicARN: !Ref NotificationTopic
NotificationTypes: ['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_LAUNCH_ERROR', 'autoscaling:EC2_INSTANCE_TERMINATE', 'autoscaling:EC2_INSTANCE_TERMINATE_ERROR']
TargetGroupARNs:
- !Ref EC2TargetGroup
VPCZoneIdentifier: !Ref Subnets
```
**JSON**
```
{
"AWSTemplateFormatVersion":"2010-09-09",
"Parameters":{
"InstanceType":{
"Description":"The EC2 instance type",
"Type":"String",
"Default":"t3.micro",
"AllowedValues":[
"t3.micro",
"t3.small",
"t3.medium"
]
},
"KeyName":{
"Description":"Name of an existing EC2 key pair to allow SSH access to the instances",
"Type":"AWS::EC2::KeyPair::KeyName"
},
"LatestAmiId":{
"Description":"The latest Amazon Linux 2 AMI from the Parameter Store",
"Type":"AWS::SSM::Parameter::Value",
"Default":"/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2"
},
"OperatorEmail":{
"Description":"The email address to notify when there are any scaling activities",
"Type":"String"
},
"SSHLocation":{
"Description":"The IP address range that can be used to SSH to the EC2 instances",
"Type":"String",
"MinLength":9,
"MaxLength":18,
"Default":"0.0.0.0/0",
"ConstraintDescription":"Must be a valid IP CIDR range of the form x.x.x.x/x."
},
"Subnets":{
"Type":"List",
"Description":"At least two public subnets in different Availability Zones in the selected VPC"
},
"VPC":{
"Type":"AWS::EC2::VPC::Id",
"Description":"A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet"
}
},
"Resources":{
"ELBSecurityGroup":{
"Type":"AWS::EC2::SecurityGroup",
"Properties":{
"GroupDescription":"ELB Security Group",
"VpcId":{
"Ref":"VPC"
},
"SecurityGroupIngress":[
{
"IpProtocol":"tcp",
"FromPort":80,
"ToPort":80,
"CidrIp":"0.0.0.0/0"
}
]
}
},
"EC2SecurityGroup":{
"Type":"AWS::EC2::SecurityGroup",
"Properties":{
"GroupDescription":"EC2 Security Group",
"VpcId":{
"Ref":"VPC"
},
"SecurityGroupIngress":[
{
"IpProtocol":"tcp",
"FromPort":80,
"ToPort":80,
"SourceSecurityGroupId":{
"Fn::GetAtt":[
"ELBSecurityGroup",
"GroupId"
]
}
},
{
"IpProtocol":"tcp",
"FromPort":22,
"ToPort":22,
"CidrIp":{
"Ref":"SSHLocation"
}
}
]
}
},
"EC2TargetGroup":{
"Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
"Properties":{
"HealthCheckIntervalSeconds":30,
"HealthCheckProtocol":"HTTP",
"HealthCheckTimeoutSeconds":15,
"HealthyThresholdCount":5,
"Matcher":{
"HttpCode":"200"
},
"Name":"EC2TargetGroup",
"Port":80,
"Protocol":"HTTP",
"TargetGroupAttributes":[
{
"Key":"deregistration_delay.timeout_seconds",
"Value":"20"
}
],
"UnhealthyThresholdCount":3,
"VpcId":{
"Ref":"VPC"
}
}
},
"ALBListener":{
"Type":"AWS::ElasticLoadBalancingV2::Listener",
"Properties":{
"DefaultActions":[
{
"Type":"forward",
"TargetGroupArn":{
"Ref":"EC2TargetGroup"
}
}
],
"LoadBalancerArn":{
"Ref":"ApplicationLoadBalancer"
},
"Port":80,
"Protocol":"HTTP"
}
},
"ApplicationLoadBalancer":{
"Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
"Properties":{
"Scheme":"internet-facing",
"Subnets":{
"Ref":"Subnets"
},
"SecurityGroups":[
{
"Fn::GetAtt":[
"ELBSecurityGroup",
"GroupId"
]
}
]
}
},
"LaunchTemplate":{
"Type":"AWS::EC2::LaunchTemplate",
"Properties":{
"LaunchTemplateName":{
"Fn::Sub":"${AWS::StackName}-launch-template"
},
"LaunchTemplateData":{
"ImageId":{
"Ref":"LatestAmiId"
},
"InstanceType":{
"Ref":"InstanceType"
},
"KeyName":{
"Ref":"KeyName"
},
"SecurityGroupIds":[
{
"Ref":"EC2SecurityGroup"
}
],
"UserData":{
"Fn::Base64":{
"Fn::Join":[
"",
[
"#!/bin/bash\n",
"yum update -y\n",
"yum install -y httpd\n",
"systemctl start httpd\n",
"systemctl enable httpd\n",
"echo \"Hello World!
\" > /var/www/html/index.html"
]
]
}
}
}
}
},
"NotificationTopic":{
"Type":"AWS::SNS::Topic",
"Properties":{
"Subscription":[
{
"Endpoint":{
"Ref":"OperatorEmail"
},
"Protocol":"email"
}
]
}
},
"WebServerGroup":{
"Type":"AWS::AutoScaling::AutoScalingGroup",
"Properties":{
"LaunchTemplate":{
"LaunchTemplateId":{
"Ref":"LaunchTemplate"
},
"Version":{
"Fn::GetAtt":[
"LaunchTemplate",
"LatestVersionNumber"
]
}
},
"MaxSize":"3",
"MinSize":"1",
"NotificationConfigurations":[
{
"TopicARN":{
"Ref":"NotificationTopic"
},
"NotificationTypes":[
"autoscaling:EC2_INSTANCE_LAUNCH",
"autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
"autoscaling:EC2_INSTANCE_TERMINATE",
"autoscaling:EC2_INSTANCE_TERMINATE_ERROR"
]
}
],
"TargetGroupARNs":[
{
"Ref":"EC2TargetGroup"
}
],
"VPCZoneIdentifier":{
"Ref":"Subnets"
}
}
}
}
}
```
## Spiegazione passo per passo del modello
La prima parte di questo modello specifica i `Parameters`. A ogni parametro deve essere assegnato un valore in fase di esecuzione per CloudFormation eseguire correttamente il provisioning dello stack. Le risorse specificate più avanti nel modello fanno riferimento a questi valori e utilizzano i dati.
+ `InstanceType`: il tipo di istanza EC2 fornito da Amazon EC2 Auto Scaling. Se non viene specificato, viene utilizzato il valore predefinito `t3.micro`.
+ `KeyName`: una coppia di chiavi EC2 esistente per consentire l'accesso SSH alle istanze.
+ `LatestAmiId`: l'Amazon Machine Image (AMI) per le istanze. Se non specificato, le tue istanze vengono avviate con un'AMI Amazon Linux 2, utilizzando un parametro AWS Systems Manager pubblico gestito da AWS. Per ulteriori informazioni, consulta [Ricerca dei parametri pubblici](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) nella *Guida per l'utente di AWS Systems Manager *.
+ `OperatorEmail`: l'indirizzo e-mail a cui desideri inviare le notifiche sulle attività di dimensionamento.
+ `SSHLocation`: l'intervallo di indirizzi IP che può essere utilizzato per inviare SSH alle istanze.
+ `Subnets`: almeno due sottoreti pubbliche in diverse zone di disponibilità.
+ `VPC`: un cloud privato virtuale (VPC) nel tuo account che consente alle risorse nelle sottoreti pubbliche di connettersi a Internet.
**Nota**
Puoi utilizzare il VPC e le sottoreti predefiniti per consentire alle istanze di accedere a Internet. In quest'ultimo caso, assicurati che il VPC abbia una sottorete mappata a ciascuna zona di disponibilità della Regione in cui stai lavorando. Per creare il load balancer, ti serviranno almeno due sottoreti pubbliche.
La parte successiva di questo modello specifica le `Resources`. Questa sezione specifica le risorse dello stack e le relative proprietà.
[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa `ELBSecurityGroup`
+ `SecurityGroupIngress`contiene una regola di ingresso TCP che consente l'accesso da *tutti gli indirizzi IP* (» CidrIp ": «0.0.0.0/0") sulla porta 80.
[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa `EC2SecurityGroup`
+ `SecurityGroupIngress` contiene due regole di ingresso: 1) una regola di ingresso TCP che consente l'accesso SSH (porta 22) dall'intervallo di indirizzi IP fornito per il parametro di input `SSHLocation` e 2) una regola di ingresso TCP che consente l'accesso dal sistema di bilanciamento del carico specificando il gruppo di sicurezza del sistema di bilanciamento del carico. La [GetAtt](resources-section-structure.md#resource-properties-getatt)funzione viene utilizzata per ottenere l'ID del gruppo di sicurezza con il nome logico`ELBSecurityGroup`.
[AWS::ElasticLoadBalancingV2::TargetGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html)risorsa `EC2TargetGroup`
+ `Port`, `Protocol` e `HealthCheckProtocol` specificano la porta (80) e il protocollo (HTTP) dell'istanza EC2 verso cui `ApplicationLoadBalancer` indirizza il traffico e che Elastic Load Balancing utilizza per verificare l'integrità delle istanze EC2.
+ `HealthCheckIntervalSeconds` specifica che le istanze EC2 hanno un intervallo di 30 secondi tra un controllo dell'integrità e un altro. Per `HealthCheckTimeoutSeconds` si intende il periodo di tempo che Elastic Load Balancing attende per una risposta della destinazione del controllo dell'integrità (15 secondi in questo esempio). Al termine del periodo di timeout, Elastic Load Balancing contrassegna il controllo dell'integrità dell'istanza EC2 come non integra. Quando un'istanza EC2 non supera tre controlli di integrità consecutivi (`UnhealthyThresholdCount`), Elastic Load Balancing interrompe l'instradamento del traffico verso quell'istanza EC2 fino a quando quell'istanza non ha cinque controlli dell'integrità consecutivi (`HealthyThresholdCount`). A quel punto, Elastic Load Balancing considera l'istanza integra e ricomincia a indirizzare il traffico verso l'istanza.
+ `TargetGroupAttributes` aggiorna il valore del ritardo di annullamento della registrazione del gruppo di destinazione a 20 secondi. Per impostazione predefinita, Elastic Load Balancing attende 300 secondi prima di completare il processo di annullamento della registrazione.
[AWS::ElasticLoadBalancingV2::Listener](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html)risorsa `ALBListener`
+ `DefaultActions` specifica la porta su cui il sistema di bilanciamento del carico ascolta, il gruppo di destinazione a cui il sistema di bilanciamento del carico inoltra le richieste e il protocollo utilizzato per instradare le richieste.
[AWS::ElasticLoadBalancingV2::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html)risorsa `ApplicationLoadBalancer`
+ `Subnets` prende il valore del parametro di input `Subnets` come elenco di sottoreti pubbliche in cui verranno creati i nodi del sistema di bilanciamento del carico.
+ `SecurityGroup` ottiene l'ID del gruppo di sicurezza che funge da firewall virtuale per i nodi del sistema di bilanciamento del carico per controllare il traffico in entrata. La [GetAtt](resources-section-structure.md#resource-properties-getatt)funzione viene utilizzata per ottenere l'ID del gruppo di sicurezza con il nome logico`ELBSecurityGroup`.
[AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)risorsa `LaunchTemplate`
+ `ImageId` prende il valore del parametro di input `LatestAmiId` come AMI da utilizzare.
+ `KeyName` prende il valore del parametro di input `KeyName` come la coppia di chiavi EC2 da usare.
+ `SecurityGroupIds` ottiene l'ID del gruppo di sicurezza con il nome logico `EC2SecurityGroup` che funge da firewall virtuale per le istanze EC2 per controllare il traffico in entrata.
+ `UserData` è uno script di configurazione che viene eseguito dopo che l'istanza è attiva e funzionante. In questo esempio, lo script installa Apache e crea un file index.html.
[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html)risorsa `NotificationTopic`
+ `Subscription` prende il valore del parametro di input `OperatorEmail` come indirizzo e-mail del destinatario delle notifiche in caso di attività di scalabilità.
AWS::AutoScaling::AutoScalingRisorsa di [gruppo](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) `WebServerGroup`
+ `MinSize` e `MaxSize` impostano il numero minimo e massimo di istanze EC2 nel gruppo con dimensionamento automatico.
+ `TargetGroupARNs` prende l'ARN del gruppo di destinazione con il nome logico `EC2TargetGroup`. Man mano che questo dimensionamento automatico si dimensiona, registra le istanze e ne annulla automaticamente la registrazione con questo gruppo di destinazione.
+ `VPCZoneIdentifier` prende il valore del parametro di input `Subnets` come elenco di sottoreti pubbliche in cui verranno create le istanze EC2.
## Fase 1: Avvio dello stack
Prima di avviare lo stack, verifica di disporre delle autorizzazioni AWS Identity and Access Management (IAM) per utilizzare tutti i seguenti servizi: Amazon EC2, Amazon EC2 Auto Scaling, Elastic Load Balancing AWS Systems Manager, Amazon SNS e. CloudFormation
La procedura seguente prevede il caricamento del modello di stack di esempio da un file. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli. Salva il file con il nome `sampleloadbalancedappstack.template`.
**Avvio del modello dello stack**
1. [Accedi e apri la console all'indirizzo /cloudformation. Console di gestione AWSCloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Scegli **Crea stack**, **Con nuove risorse (standard)**.
1. In **Specifica modello**, seleziona **Carica un file di modello** e poi **Scegli file** per caricare il file `sampleloadbalancedappstack.template`.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Specifica i dettagli dello stack**, immetti il nome dello stack (ad esempio, **SampleLoadBalancedAppStack**).
1. **In **Parametri**, esamina i parametri per lo stack e fornisci i valori per tutti i parametri che non hanno valori predefiniti, tra cui **OperatorEmail**, **SSHLocation**KeyName****, **VPC** e sottoreti.**
1. Scegliere **Next (Successivo)** due volte.
1. Nella pagina **Rivedi**, verifica e conferma le impostazioni.
1. Seleziona **Invia**.
**Puoi visualizzare lo stato dello stack nella CloudFormation console nella colonna Stato.** **Una volta CloudFormation creato con successo lo stack, ricevi lo stato CREATE\$1COMPLETE.**
**Nota**
Dopo aver creato lo stack, perché l'indirizzo e-mail possa iniziare a ricevere notifiche devi confermare la sottoscrizione. Per ulteriori informazioni, consulta l'argomento relativo alla [ricezione di notifiche Amazon SNS quando il gruppo di dimensionamento automatico viene dimensionato](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-sns-notifications.html) nella *Guida per l'utente di Amazon EC2 Auto Scaling*.
## Fase 2: Cancellazione delle risorse di esempio
Per assicurarti che non ti vengano addebitati costi per le risorse di esempio inutilizzate, elimina lo stack.
**Per eliminare lo stack**
1. Nella CloudFormation console, seleziona lo stack. **SampleLoadBalancedAppStack**
1. Scegli **Elimina**.
1. Nel messaggio di conferma, scegli **Elimina stack**.
Lo stato delle **SampleLoadBalancedAppStack**modifiche a **DELETE\$1IN\$1PROGRESS**. Una volta CloudFormation completata l'eliminazione dello stack, lo rimuove dall'elenco.
Usa i modelli di esempio di questa procedura guidata per creare i tuoi modelli stack. Per ulteriori informazioni, consulta [Tutorial: Configurazione di un'applicazione con dimensionata e con bilanciamento del carico](https://docs.aws.amazon.com/autoscaling/ec2/userguide/tutorial-ec2-auto-scaling-load-balancer.html) nella *Guida per l'utente di Amazon EC2 Auto Scaling*.
# Peer con un VPC in un altro Account AWS
È possibile effettuare il peering con un Virtual Private Cloud (VPC) in un altro utilizzando. Account AWS [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html) In questo modo si crea una connessione di rete tra due di essi VPCs che consente di instradare il traffico tra di loro in modo che possano comunicare come se fossero all'interno della stessa rete. Una connessione peering VPC può facilitare l’accesso ai dati e il trasferimento dei dati.
Per stabilire una connessione peering VPC, devi autorizzarne due separate Account AWS all'interno di un unico stack. CloudFormation
Per ulteriori informazioni sul peering di VPC e le sue limitazioni, consulta la [Guida al peering di Amazon VPC](https://docs.aws.amazon.com/vpc/latest/peering/).
## Prerequisiti
1. Per la connessione peering sono necessari un ID VPC peer, un Account AWS peer ID e [un ruolo di accesso tra account diversi](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
**Nota**
Questa procedura guidata si riferisce a due account: un account che consente il peering tra più account (l’*account dell’accettante*) e un account che richiede la connessione in peering (l’*account del richiedente*).
1. Per accettare la connessione peering VPC, devi assumere il ruolo di accesso multi-account. La risorsa si comporta nello stesso modo di una risorsa di una connessione peering VPC nello stesso account. Per informazioni su come un amministratore IAM concede le autorizzazioni per assumere il ruolo di multi-account, consulta [Grant a user permissions to switch roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) nella *Guida per l’utente di IAM*.
## Fase 1: creazione di un VPC e di un ruolo tra più account
In questa fase vengono creati il VPC e il ruolo nell’*account dell’accettante*.
**Creazione di un VPC e di un ruolo di accesso multi-account**
1. [Accedi e apri la console all'indirizzo Console di gestione AWS /cloudformazione. CloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Nella pagina **Stack** scegli **Crea stack** in alto a destra, quindi seleziona **Con nuove risorse (standard)**.
1. Per **Prerequisito: prepara modello**, scegli **Scegli un modello esistente**, quindi **Carica un file modello**, **Scegli file**.
1. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli seguenti. Salva il file e torna alla console per selezionarlo come file modello.
**Example JSON**
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "Create a VPC and an assumable role for cross account VPC peering.",
"Parameters": {
"PeerRequesterAccountId": {
"Type": "String"
}
},
"Resources": {
"vpc": {
"Type": "AWS::EC2::VPC",
"Properties": {
"CidrBlock": "10.1.0.0/16",
"EnableDnsSupport": false,
"EnableDnsHostnames": false,
"InstanceTenancy": "default"
}
},
"peerRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Statement": [
{
"Principal": {
"AWS": {
"Ref": "PeerRequesterAccountId"
}
},
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "root",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:AcceptVpcPeeringConnection",
"Resource": "*"
}
]
}
}
]
}
}
},
"Outputs": {
"VPCId": {
"Value": {
"Ref": "vpc"
}
},
"RoleARN": {
"Value": {
"Fn::GetAtt": [
"peerRole",
"Arn"
]
}
}
}
}
```
**Example YAML**
```
AWSTemplateFormatVersion: 2010-09-09
Description: Create a VPC and an assumable role for cross account VPC peering.
Parameters:
PeerRequesterAccountId:
Type: String
Resources:
vpc:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.1.0.0/16
EnableDnsSupport: false
EnableDnsHostnames: false
InstanceTenancy: default
peerRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Principal:
AWS: !Ref PeerRequesterAccountId
Action:
- 'sts:AssumeRole'
Effect: Allow
Path: /
Policies:
- PolicyName: root
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action: 'ec2:AcceptVpcPeeringConnection'
Resource: '*'
Outputs:
VPCId:
Value: !Ref vpc
RoleARN:
Value: !GetAtt
- peerRole
- Arn
```
1. Scegli **Next (Successivo)**.
1. Assegna un nome allo stack (ad esempio,**VPC-owner**), quindi inserisci l' Account AWS ID dell'account *richiedente* nel campo. **PeerRequesterAccountId**
1. Accettare i valori predefiniti, quindi selezionare **Next (Avanti)**.
1. Scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create** stack.
## Fase 2: creazione di un modello che include `AWS::EC2::VPCPeeringConnection`
*Ora che hai creato il VPC e il ruolo interaccount, puoi effettuare il peer con il VPC utilizzandone un altro Account AWS (l'account richiedente).*
**Per creare un modello che includa la risorsa [AWS: :EC2:: Connection VPCPeering](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html)**
1. Torna alla home page della CloudFormation console.
1. Nella pagina **Stack** scegli **Crea stack** in alto a destra, quindi seleziona **Con nuove risorse (standard)**.
1. Per **Prerequisito: prepara modello**, scegli **Scegli un modello esistente**, quindi **Carica un file modello**, **Scegli file**.
1. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli seguenti. Salva il file e torna alla console per selezionarlo come file modello.
**Example JSON**
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "Create a VPC and a VPC Peering connection using the PeerRole to accept.",
"Parameters": {
"PeerVPCAccountId": {
"Type": "String"
},
"PeerVPCId": {
"Type": "String"
},
"PeerRoleArn": {
"Type": "String"
}
},
"Resources": {
"vpc": {
"Type": "AWS::EC2::VPC",
"Properties": {
"CidrBlock": "10.2.0.0/16",
"EnableDnsSupport": false,
"EnableDnsHostnames": false,
"InstanceTenancy": "default"
}
},
"vpcPeeringConnection": {
"Type": "AWS::EC2::VPCPeeringConnection",
"Properties": {
"VpcId": {
"Ref": "vpc"
},
"PeerVpcId": {
"Ref": "PeerVPCId"
},
"PeerOwnerId": {
"Ref": "PeerVPCAccountId"
},
"PeerRoleArn": {
"Ref": "PeerRoleArn"
}
}
}
},
"Outputs": {
"VPCId": {
"Value": {
"Ref": "vpc"
}
},
"VPCPeeringConnectionId": {
"Value": {
"Ref": "vpcPeeringConnection"
}
}
}
}
```
**Example YAML**
```
AWSTemplateFormatVersion: 2010-09-09
Description: Create a VPC and a VPC Peering connection using the PeerRole to accept.
Parameters:
PeerVPCAccountId:
Type: String
PeerVPCId:
Type: String
PeerRoleArn:
Type: String
Resources:
vpc:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.2.0.0/16
EnableDnsSupport: false
EnableDnsHostnames: false
InstanceTenancy: default
vpcPeeringConnection:
Type: AWS::EC2::VPCPeeringConnection
Properties:
VpcId: !Ref vpc
PeerVpcId: !Ref PeerVPCId
PeerOwnerId: !Ref PeerVPCAccountId
PeerRoleArn: !Ref PeerRoleArn
Outputs:
VPCId:
Value: !Ref vpc
VPCPeeringConnectionId:
Value: !Ref vpcPeeringConnection
```
1. Scegli **Next (Successivo)**.
1. Assegnare un nome allo stack (ad esempio, **VPC-peering-connection**).
1. Accettare i valori predefiniti, quindi selezionare **Next (Avanti)**.
1. Scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create stack**.
## Creazione di un modello con una policy altamente restrittiva
Potresti creare una policy altamente restrittiva per collegare in peering il VPC con un altro Account AWS.
L’esempio seguente mostra come modificare il modello del proprietario della connessione in peering del VPC (l’*account dell’accettante* creato nella fase 1 precedente) in modo che sia di livello più restrittivo.
**Example JSON**
```
{
"AWSTemplateFormatVersion":"2010-09-09",
"Description":"Create a VPC and an assumable role for cross account VPC peering.",
"Parameters":{
"PeerRequesterAccountId":{
"Type":"String"
}
},
"Resources":{
"peerRole":{
"Type":"AWS::IAM::Role",
"Properties":{
"AssumeRolePolicyDocument":{
"Statement":[
{
"Action":[
"sts:AssumeRole"
],
"Effect":"Allow",
"Principal":{
"AWS":{
"Ref":"PeerRequesterAccountId"
}
}
}
]
},
"Path":"/",
"Policies":[
{
"PolicyDocument":{
"Statement":[
{
"Action":"ec2:acceptVpcPeeringConnection",
"Effect":"Allow",
"Resource":{
"Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
}
},
{
"Action":"ec2:acceptVpcPeeringConnection",
"Condition":{
"StringEquals":{
"ec2:AccepterVpc":{
"Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
}
}
},
"Effect":"Allow",
"Resource":{
"Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*"
}
}
],
"Version":"2012-10-17"
},
"PolicyName":"root"
}
]
}
},
"vpc":{
"Type":"AWS::EC2::VPC",
"Properties":{
"CidrBlock":"10.1.0.0/16",
"EnableDnsHostnames":false,
"EnableDnsSupport":false,
"InstanceTenancy":"default"
}
}
},
"Outputs":{
"RoleARN":{
"Value":{
"Fn::GetAtt":[
"peerRole",
"Arn"
]
}
},
"VPCId":{
"Value":{
"Ref":"vpc"
}
}
}
}
```
**Example YAML**
```
AWSTemplateFormatVersion: 2010-09-09
Description: Create a VPC and an assumable role for cross account VPC peering.
Parameters:
PeerRequesterAccountId:
Type: String
Resources:
peerRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action:
- 'sts:AssumeRole'
Effect: Allow
Principal:
AWS:
Ref: PeerRequesterAccountId
Path: /
Policies:
- PolicyDocument:
Statement:
- Action: 'ec2:acceptVpcPeeringConnection'
Effect: Allow
Resource:
'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
- Action: 'ec2:acceptVpcPeeringConnection'
Condition:
StringEquals:
'ec2:AccepterVpc':
'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
Effect: Allow
Resource:
'Fn::Sub': >-
arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*
Version: 2012-10-17
PolicyName: root
vpc:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.1.0.0/16
EnableDnsHostnames: false
EnableDnsSupport: false
InstanceTenancy: default
Outputs:
RoleARN:
Value:
'Fn::GetAtt':
- peerRole
- Arn
VPCId:
Value:
Ref: vpc
```
Per accedere al VPC, è possibile utilizzare lo stesso modello del richiedente della fase 2 precedente.
Per ulteriori informazioni, consulta [Identity and access management for VPC peering](https://docs.aws.amazon.com/vpc/latest/peering/security-iam.html) nella *Guida al peering di Amazon VPC*.
# Esegui le blue/green implementazioni ECS tramite l'utilizzo CodeDeploy CloudFormation
Per aggiornare un'applicazione in esecuzione su Amazon Elastic Container Service (Amazon ECS), puoi utilizzare CodeDeploy una strategia di distribuzione blu/verde. Questa strategia aiuta a ridurre al minimo le interruzioni causate dalla modifica delle versioni delle applicazioni.
*In una blue/green distribuzione, crei un nuovo ambiente applicativo (denominato *verde*) accanto all'ambiente live corrente (denominato blu).* Ciò ti consente di monitorare e testare l’ambiente verde prima di indirizzare il traffico live dall’ambiente blu a quello verde. Dopo che l’ambiente verde ha fornito traffico live, puoi terminare l’ambiente blu in modo sicuro.
Per eseguire distribuzioni CodeDeploy blu/verdi su ECS utilizzando CloudFormation, includi le seguenti informazioni nel modello di stack:
+ Una sezione `Hooks` che descrive un hook `AWS::CodeDeploy::BlueGreen`.
+ Una sezione `Transform` che specifica la trasformazione `AWS::CodeDeployBlueGreen`.
I seguenti argomenti ti guidano nella configurazione di un CloudFormation modello per una distribuzione blu/verde su ECS.
**Topics**
+ [Informazioni sulle blue/green distribuzioni](about-blue-green-deployments.md)
+ [Considerazioni sulla gestione delle distribuzioni ECS utilizzando blue/green CloudFormation](blue-green-considerations.md)
+ [Sintassi di hook `AWS::CodeDeploy::BlueGreen`](blue-green-hook-syntax.md)
+ [Esempio di modello di implementazione blu/verde](blue-green-template-example.md)
# Informazioni sulle blue/green distribuzioni
Questo argomento fornisce una panoramica di come funziona l'esecuzione blue/green delle distribuzioni con. CloudFormation Spiega inoltre come preparare il CloudFormation modello per le distribuzioni blu/verdi.
**Topics**
+ [Come funziona](#blue-green-how-it-works)
+ [Aggiornamenti delle risorse che avviano le implementazioni verdi](#blue-green-resources)
+ [Preparazione del modello](#blue-green-setup)
+ [Modellazione della distribuzione blue/green](#blue-green-required)
+ [Set di modifiche](#blue-green-changesets)
+ [Monitoraggio degli eventi dello stack](#blue-green-events)
+ [autorizzazioni IAM](#blue-green-iam)
## Come funziona
Quando si utilizza CloudFormation per eseguire blue/green distribuzioni ECS tramite CodeDeploy, si inizia con la creazione di un modello di stack che definisce le risorse per gli ambienti applicativi blu e verdi, inclusa la specificazione delle impostazioni di routing e stabilizzazione del traffico da utilizzare. Successivamente, crea uno stack da quel modello. Questo genera l'applicazione blu (corrente). CloudFormation crea le risorse blu solo durante la creazione dello stack. Le risorse per una distribuzione verde non vengono create finché non sono necessarie.
Quindi, se in un futuro aggiornamento dello stack aggiorni la definizione dell'attività o le risorse del set di attività nell'applicazione blu, CloudFormation effettua le seguenti operazioni:
+ Genera tutte le risorse necessarie per l’ambiente delle applicazioni verdi
+ Sposta il traffico in base ai parametri di instradamento del traffico specificati
+ Elimina le risorse blu
Se si verifica un errore in qualsiasi momento prima che la distribuzione verde abbia esito positivo e sia finalizzata, CloudFormation ripristina lo stack allo stato precedente all'avvio dell'intera distribuzione verde.
## Aggiornamenti delle risorse che avviano le implementazioni verdi
Quando si esegue un aggiornamento dello stack che aggiorna determinate proprietà di risorse ECS specifiche, CloudFormation avvia un processo di distribuzione verde. Le risorse che avviano questo processo sono:
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html)
Tuttavia, se gli aggiornamenti a queste risorse non comportano modifiche alle proprietà che richiedono la sostituzione, non verrà avviata un’implementazione verde. Per ulteriori informazioni, consulta [Comprendere l’aggiornamento dei comportamenti delle risorse stack](using-cfn-updating-stacks-update-behaviors.md).
È importante notare che non puoi unire gli aggiornamenti delle risorse di cui sopra con gli aggiornamenti di altre risorse nella stessa operazione di aggiornamento dello stack. Se devi aggiornare sia le risorse elencate che altre risorse all’interno dello stesso stack, hai due opzioni:
+ Eseguire due operazioni di aggiornamento separate: una che include solo gli aggiornamenti delle risorse precedenti e un aggiornamento separato dello stack che include le modifiche apportate a qualsiasi altra risorsa.
+ Rimuovi le sezioni `Transform` e `Hooks` dal modello e quindi esegui l’aggiornamento dello stack. In questo caso, CloudFormation non eseguirà una distribuzione ecologica.
## Preparazione del modello per eseguire le distribuzioni ECS blue/green
Per abilitare le blue/green distribuzioni sul tuo stack, includi le seguenti sezioni nel tuo modello di stack prima di eseguire un aggiornamento dello stack.
+ Aggiungi un riferimento alla trasformazione `AWS::CodeDeployBlueGreen` al tuo modello:
```
"Transform": [
"AWS::CodeDeployBlueGreen"
],
```
+ Aggiungi una sezione `Hooks` che richiami l’hook `AWS::CodeDeploy::BlueGreen` e specifica le proprietà per la distribuzione. Per ulteriori informazioni, consulta [Sintassi di hook `AWS::CodeDeploy::BlueGreen`](blue-green-hook-syntax.md).
+ Nella sezione `Resources`, definisci le risorse blu e verdi per la distribuzione.
È possibile aggiungere queste sezioni quando si crea il modello per la prima volta o prima di creare lo stack medesimo; oppure è possibile aggiungerle a un modello esistente prima di eseguire un aggiornamento dello stack. Se specifichi la blue/green distribuzione per un nuovo stack, crea CloudFormation solo le risorse blu durante la creazione dello stack. Le risorse per la distribuzione verde non vengono create finché non sono necessarie durante un aggiornamento dello stack.
## Modellazione della distribuzione utilizzando le risorse blue/green CloudFormation
Per eseguire una distribuzione CodeDeploy blu/verde su ECS, il CloudFormation modello deve includere le risorse che modellano la distribuzione, come un servizio Amazon ECS e un sistema di bilanciamento del carico. Per ulteriori dettagli su cosa rappresentano queste risorse, consulta [Prima di iniziare una distribuzione Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps-ecs.html#deployment-steps-prerequisites-ecs) nella *Guida per l’utente di AWS CodeDeploy *.
| Requisito | Risorsa | Obbligatorio/facoltativo | Avvia la distribuzione in caso di sostituzione? blue/green |
| --- | --- | --- | --- |
| Cluster Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html) | Opzionale. Puoi utilizzare il cluster predefinito. | No |
| Servizio Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html) | Obbligatorio. | No |
| Applicazione o Network Load Balancer | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html) | Obbligatorio. | No |
| Listener di produzione | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Obbligatorio. | No |
| Listener di prova | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Opzionale. | No |
| Due gruppi target | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) | Obbligatorio. | No |
| Definizione dell’attività di Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) | Obbligatorio. | Sì |
| Container per l’applicazione Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name) | Obbligatorio. | No |
| Porta per il set di attività di sostituzione | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport) | Obbligatorio. | No |
## Set di modifiche
Consigliamo vivamente di creare un set di modifiche prima di eseguire un aggiornamento dello stack che inizierà una distribuzione verde. Ciò ti consente di visualizzare le modifiche effettive che verranno apportate allo stack prima di procedere con l’aggiornamento. Tieni presente che le modifiche alle risorse potrebbero non essere elencate nell’ordine in cui verranno eseguite durante l’aggiornamento dello stack. Per ulteriori informazioni, consulta [Aggiorna CloudFormation gli stack utilizzando i set di modifiche](using-cfn-updating-stacks-changesets.md).
## Monitoraggio degli eventi dello stack
È possibile visualizzare gli eventi stack generati in ogni fase dell’implementazione ECS nella scheda **Events** (Eventi) della pagina **Stack** oppure utilizzando AWS CLI. Per ulteriori informazioni, consulta [Monitoraggio dell’avanzamento dello stack](monitor-stack-progress.md).
## Autorizzazioni IAM per le distribuzioni blue/green
CloudFormation Per eseguire correttamente le distribuzioni blu-verdi, devi disporre delle seguenti autorizzazioni: CodeDeploy
+ `codedeploy:Get*`
+ `codedeploy:CreateCloudFormationDeployment`
Per ulteriori informazioni, consulta [Operazioni, risorse e chiavi di condizione per CodeDeploy](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscodedeploy.html) nella *Documentiazione di riferimento per l'autorizzazione al servizio*.
# Considerazioni sulla gestione delle distribuzioni ECS utilizzando blue/green CloudFormation
Il processo di utilizzo CloudFormation per eseguire le blue/green distribuzioni ECS CodeDeploy è diverso da quello di una distribuzione ECS standard che utilizza just. CodeDeploy *Per una comprensione dettagliata di queste differenze, consulta [Differenze tra le blue/green distribuzioni di Amazon ECS tramite CodeDeploy e CloudFormation](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments-create-ecs-cfn.html#differences-ecs-bg-cfn) nella Guida per l'AWS CodeDeploy utente.*
Quando si gestisce la blue/green distribuzione utilizzando CloudFormation, ci sono alcune limitazioni e considerazioni da tenere a mente:
+ Solo gli aggiornamenti di determinate risorse inizieranno un’implementazione verde. Per ulteriori informazioni, consulta [Aggiornamenti delle risorse che avviano le implementazioni verdi](about-blue-green-deployments.md#blue-green-resources).
+ Non puoi includere gli aggiornamenti delle risorse che iniziano implementazioni verdi e aggiornamenti ad altre risorse nello stesso aggiornamento dello stack. Per ulteriori informazioni, consulta [Aggiornamenti delle risorse che avviano le implementazioni verdi](about-blue-green-deployments.md#blue-green-resources).
+ Puoi specificare solo una singola applicazione ECS come target di distribuzione.
+ I parametri i cui valori sono offuscati non CloudFormation possono essere aggiornati CodeDeploy durante una distribuzione ecologica e causeranno un errore e un errore di aggiornamento dello stack. Ciò include:
+ Parametri definiti con l’attributo `NoEcho`.
+ Parametri che utilizzano riferimenti dinamici per recuperare i loro valori da servizi esterni. Per ulteriori informazioni sui riferimenti dinamici, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).
+ Per annullare una distribuzione ecologica ancora in corso, annulla lo stack update in CloudFormation, not o ECS. CodeDeploy Per ulteriori informazioni, consulta [Annulla l’aggiornamento di uno stack](using-cfn-stack-update-cancel.md). Dopo che un aggiornamento è terminato, non è possibile annullarlo. Tuttavia, puoi aggiornare uno stack di nuovo con le impostazioni precedenti.
+ Le seguenti CloudFormation funzionalità non sono attualmente supportate per i modelli che definiscono le distribuzioni ECS blue/green :
+ Dichiarazione degli [output](outputs-section-structure.md) o utilizzo di [Fn:: ImportValue](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html) per importare valori da altri stack.
+ Importare risorse Per ulteriori informazioni sull’importazione delle risorse, consulta [Importa AWS risorse in una CloudFormation pila](import-resources.md).
+ Utilizzare l’hook `AWS::CodeDeploy::BlueGreen` in un modello che include risorse di stack nidificate. Per ulteriori informazioni sugli stack nidificati, consulta [Dividi un modello in pezzi riutilizzabili usando stack nidificati](using-cfn-nested-stacks.md).
+ Utilizzo dell’hook `AWS::CodeDeploy::BlueGreen` in uno stack nidificato.
# Sintassi di hook `AWS::CodeDeploy::BlueGreen`
La sintassi seguente descrive la struttura di un `AWS::CodeDeploy::BlueGreen` hook per le distribuzioni ECS. blue/green
## Sintassi
```
"Hooks": {
"Logical ID": {
"Type": "AWS::CodeDeploy::BlueGreen",
"Properties": {
"TrafficRoutingConfig": {
"Type": "Traffic routing type",
"TimeBasedCanary": {
"StepPercentage": Integer,
"BakeTimeMins": Integer
},
"TimeBasedLinear": {
"StepPercentage": Integer,
"BakeTimeMins": Integer
}
},
"AdditionalOptions": {"TerminationWaitTimeInMinutes": Integer},
"LifecycleEventHooks": {
"BeforeInstall": "FunctionName",
"AfterInstall": "FunctionName",
"AfterAllowTestTraffic": "FunctionName",
"BeforeAllowTraffic": "FunctionName",
"AfterAllowTraffic": "FunctionName"
},
"ServiceRole": "CodeDeployServiceRoleName",
"Applications": [
{
"Target": {
"Type": "AWS::ECS::Service",
"LogicalID": "Logical ID of AWS::ECS::Service"
},
"ECSAttributes": {
"TaskDefinitions": [
"Logical ID of AWS::ECS::TaskDefinition (Blue)",
"Logical ID of AWS::ECS::TaskDefinition (Green)"
],
"TaskSets": [
"Logical ID of AWS::ECS::TaskSet (Blue)",
"Logical ID of AWS::ECS::TaskSet (Green)"
],
"TrafficRouting": {
"ProdTrafficRoute": {
"Type": "AWS::ElasticLoadBalancingV2::Listener",
"LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Production)"
},
"TestTrafficRoute": {
"Type": "AWS::ElasticLoadBalancingV2::Listener",
"LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Test)"
},
"TargetGroups": [
"Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Blue)",
"Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Green)"
]
}
}
}
]
}
}
}
```
## Properties
ID logico (chiamato anche *nome logico)*
L’ID logico di un hook dichiarato nella sezione `Hooks` del modello. L’ID logico deve essere un valore alfanumerico (A-Z, a-z, 0-9) univoco all’interno del modello.
*Obbligatorio:* sì
`Type`
Il tipo di hook. `AWS::CodeDeploy::BlueGreen`
*Obbligatorio:* sì
`Properties`
Proprietà dell’hook.
*Obbligatorio:* sì
`TrafficRoutingConfig`
Impostazioni di configurazione dell’instradamento del traffico.
*Obbligatorio:* no
La configurazione predefinita è lo spostamento del traffico canary basato sul tempo, con una percentuale di fasi del 15% e un tempo di cottura di cinque minuti.
`Type`
Tipo di spostamento del traffico utilizzato dalla configurazione di distribuzione.
Valori validi: \$1 \$1 AllAtOnce TimeBasedCanary TimeBasedLinear
*Obbligatorio:* sì
`TimeBasedCanary`
Specifica una configurazione che sposta il traffico da una versione della distribuzione a un’altra con due incrementi.
*Obbligatorio*: condizionale: se si specifica `TimeBasedCanary` come tipo di instradamento del traffico, è necessario includere il parametro `TimeBasedCanary`.
`StepPercentage`
Percentuale di traffico da spostare nel primo incremento di una distribuzione `TimeBasedCanary`. La percentuale di fasi deve essere pari o superiore al 14%.
*Obbligatorio:* no
`BakeTimeMins`
Numero di minuti tra il primo e il secondo spostamento di traffico di una distribuzione `TimeBasedCanary`.
*Obbligatorio:* no
`TimeBasedLinear`
Specifica una configurazione che sposta il traffico da una versione della distribuzione a un’altra con incrementi uguali, con un numero uguale di minuti tra ciascun incremento.
*Obbligatorio*: condizionale: se si specifica `TimeBasedLinear` come tipo di instradamento del traffico, è necessario includere il parametro `TimeBasedLinear`.
`StepPercentage`
Percentuale di traffico spostata all’inizio di ogni incremento di una distribuzione `TimeBasedLinear`. La percentuale di fasi deve essere pari o superiore al 14%.
*Obbligatorio:* no
`BakeTimeMins`
Numero di minuti tra ogni spostamento incrementale del traffico di una distribuzione `TimeBasedLinear`.
*Obbligatorio:* no
`AdditionalOptions`
Opzioni aggiuntive per la blue/green distribuzione.
*Obbligatorio:* no
`TerminationWaitTimeInMinutes`
Specifica il tempo di attesa, in minuti, prima di terminare le risorse blu.
*Obbligatorio:* no
`LifecycleEventHooks`
Usa gli hook degli eventi del ciclo di vita per specificare una funzione Lambda che CodeDeploy può chiamare per convalidare una distribuzione. Puoi utilizzare la stessa funzione o un’altra per gli eventi del ciclo di vita di distribuzione. Dopo il completamento dei test di convalida, la funzione `AfterAllowTraffic` Lambda CodeDeploy richiama e fornisce il risultato `Succeeded` di o. `Failed` *Per ulteriori informazioni, consulta la [sezione AppSpec 'hook'](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-hooks.html) nella Guida per l'AWS CodeDeploy utente.*
*Obbligatorio:* no
`BeforeInstall`
Funzione utilizzata per eseguire attività prima della creazione del set di attività di sostituzione.
*Obbligatorio:* no
`AfterInstall`
Funzione utilizzata per eseguire attività dopo che il set di attività di sostituzione è stato creato e a esso è stato associato uno dei gruppi target.
*Obbligatorio:* no
`AfterAllowTestTraffic`
Funzione utilizzata per eseguire attività dopo che il listener di test ha indirizzato il traffico verso il set di attività di sostituzione.
*Obbligatorio:* no
`BeforeAllowTraffic`
Funzione utilizzata per eseguire attività dopo che il secondo gruppo target è stato associato al set di attività di sostituzione, ma prima che il traffico venga reindirizzato al set di attività di sostituzione.
*Obbligatorio:* no
`AfterAllowTraffic`
Funzione utilizzata per eseguire attività dopo che il secondo gruppo target ha indirizzato il traffico verso il set di attività di sostituzione.
*Obbligatorio:* no
`ServiceRole`
Il ruolo di esecuzione CloudFormation da utilizzare per eseguire le distribuzioni blu-verdi. Per un elenco delle autorizzazioni necessarie, consulta [Autorizzazioni IAM per le distribuzioni blue/green](about-blue-green-deployments.md#blue-green-iam).
*Obbligatorio:* no
`Applications`
Specifica le proprietà dell’applicazione Amazon ECS.
*Obbligatorio:* sì
`Target`
*Obbligatorio:* sì
`Type`
Il tipo di risorsa.
*Obbligatorio:* sì
`LogicalID`
L’ID logico della risorsa.
*Obbligatorio:* sì
`ECSAttributes`
Le risorse che rappresentano i vari requisiti della distribuzione dell’applicazione Amazon ECS.
*Obbligatorio:* sì
`TaskDefinitions`
ID logico della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) per eseguire il container Docker che contiene l’applicazione Amazon ECS.
*Obbligatorio:* sì
`TaskSets`
La logica IDs delle [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html)risorse da utilizzare come set di attività per l'applicazione.
*Obbligatorio:* sì
`TrafficRouting`
Specifica le risorse utilizzate per l’instradamento del traffico.
*Obbligatorio:* sì
`ProdTrafficRoute`
Il listener che viene utilizzato dal load balancer per indirizzare il traffico verso i gruppi target.
*Obbligatorio:* sì
`Type`
Il tipo di risorsa. `AWS::ElasticLoadBalancingV2::Listener`
*Obbligatorio:* sì
`LogicalID`
L’ID logico della risorsa.
*Obbligatorio:* sì
`TestTrafficRoute`
Il listener che viene utilizzato dal load balancer per indirizzare il traffico verso i gruppi target.
*Obbligatorio:* sì
`Type`
Il tipo di risorsa. `AWS::ElasticLoadBalancingV2::Listener`
*Obbligatorio:* sì
`LogicalID`
L’ID logico della risorsa.
*Obbligatorio:* no
`TargetGroups`
ID logico delle risorse da utilizzare come target per instradare il traffico al target registrato.
*Obbligatorio:* sì
# Esempio di modello di implementazione blu/verde
Il modello di esempio seguente configura una distribuzione CodeDeploy blu/verde su ECS, con un avanzamento del routing del traffico del 15% per fase e un periodo di stabilizzazione di 5 minuti tra ogni passaggio.
La creazione di uno stack con il modello prevede il provisioning della configurazione iniziale dell’implementazione. Se in seguito sono state apportate modifiche alle proprietà della `BlueTaskSet` risorsa che richiedono la sostituzione di tale risorsa, CloudFormation verrà avviata una distribuzione ecologica come parte dell'aggiornamento dello stack.
## JSON
```
{
"AWSTemplateFormatVersion":"2010-09-09",
"Parameters":{
"Vpc":{ "Type":"AWS::EC2::VPC::Id" },
"Subnet1":{ "Type":"AWS::EC2::Subnet::Id" },
"Subnet2":{ "Type":"AWS::EC2::Subnet::Id" }
},
"Transform":[ "AWS::CodeDeployBlueGreen" ],
"Hooks":{
"CodeDeployBlueGreenHook":{
"Type":"AWS::CodeDeploy::BlueGreen",
"Properties":{
"TrafficRoutingConfig":{
"Type":"TimeBasedCanary",
"TimeBasedCanary":{
"StepPercentage":15,
"BakeTimeMins":5
}
},
"Applications":[
{
"Target":{
"Type":"AWS::ECS::Service",
"LogicalID":"ECSDemoService"
},
"ECSAttributes":{
"TaskDefinitions":[ "BlueTaskDefinition","GreenTaskDefinition" ],
"TaskSets":[ "BlueTaskSet","GreenTaskSet" ],
"TrafficRouting":{
"ProdTrafficRoute":{
"Type":"AWS::ElasticLoadBalancingV2::Listener",
"LogicalID":"ALBListenerProdTraffic"
},
"TargetGroups":[ "ALBTargetGroupBlue","ALBTargetGroupGreen" ]
}
}
}
]
}
}
},
"Resources":{
"ExampleSecurityGroup":{
"Type":"AWS::EC2::SecurityGroup",
"Properties":{
"GroupDescription":"Security group for ec2 access",
"VpcId":{ "Ref":"Vpc" },
"SecurityGroupIngress":[
{
"IpProtocol":"tcp",
"FromPort":80,
"ToPort":80,
"CidrIp":"0.0.0.0/0"
},
{
"IpProtocol":"tcp",
"FromPort":8080,
"ToPort":8080,
"CidrIp":"0.0.0.0/0"
},
{
"IpProtocol":"tcp",
"FromPort":22,
"ToPort":22,
"CidrIp":"0.0.0.0/0"
}
]
}
},
"ALBTargetGroupBlue":{
"Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
"Properties":{
"HealthCheckIntervalSeconds":5,
"HealthCheckPath":"/",
"HealthCheckPort":"80",
"HealthCheckProtocol":"HTTP",
"HealthCheckTimeoutSeconds":2,
"HealthyThresholdCount":2,
"Matcher":{ "HttpCode":"200" },
"Port":80,
"Protocol":"HTTP",
"Tags":[{ "Key":"Group","Value":"Example" }],
"TargetType":"ip",
"UnhealthyThresholdCount":4,
"VpcId":{ "Ref":"Vpc" }
}
},
"ALBTargetGroupGreen":{
"Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
"Properties":{
"HealthCheckIntervalSeconds":5,
"HealthCheckPath":"/",
"HealthCheckPort":"80",
"HealthCheckProtocol":"HTTP",
"HealthCheckTimeoutSeconds":2,
"HealthyThresholdCount":2,
"Matcher":{ "HttpCode":"200" },
"Port":80,
"Protocol":"HTTP",
"Tags":[{ "Key":"Group","Value":"Example" }],
"TargetType":"ip",
"UnhealthyThresholdCount":4,
"VpcId":{ "Ref":"Vpc" }
}
},
"ExampleALB":{
"Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
"Properties":{
"Scheme":"internet-facing",
"SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
"Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }],
"Tags":[{ "Key":"Group","Value":"Example" }],
"Type":"application",
"IpAddressType":"ipv4"
}
},
"ALBListenerProdTraffic":{
"Type":"AWS::ElasticLoadBalancingV2::Listener",
"Properties":{
"DefaultActions":[
{
"Type":"forward",
"ForwardConfig":{
"TargetGroups":[
{
"TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
"Weight":1
}
]
}
}
],
"LoadBalancerArn":{ "Ref":"ExampleALB" },
"Port":80,
"Protocol":"HTTP"
}
},
"ALBListenerProdRule":{
"Type":"AWS::ElasticLoadBalancingV2::ListenerRule",
"Properties":{
"Actions":[
{
"Type":"forward",
"ForwardConfig":{
"TargetGroups":[
{
"TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
"Weight":1
}
]
}
}
],
"Conditions":[
{
"Field":"http-header",
"HttpHeaderConfig":{
"HttpHeaderName":"User-Agent",
"Values":[ "Mozilla" ]
}
}
],
"ListenerArn":{ "Ref":"ALBListenerProdTraffic" },
"Priority":1
}
},
"ECSTaskExecutionRole":{
"Type":"AWS::IAM::Role",
"Properties":{
"AssumeRolePolicyDocument":{
"Version": "2012-10-17",
"Statement":[
{
"Sid":"",
"Effect":"Allow",
"Principal":{
"Service":"ecs-tasks.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
},
"ManagedPolicyArns":[ "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy" ]
}
},
"BlueTaskDefinition":{
"Type":"AWS::ECS::TaskDefinition",
"Properties":{
"ExecutionRoleArn":{
"Fn::GetAtt":[ "ECSTaskExecutionRole","Arn" ]
},
"ContainerDefinitions":[
{
"Name":"DemoApp",
"Image":"nginxdemos/hello:latest",
"Essential":true,
"PortMappings":[
{
"HostPort":80,
"Protocol":"tcp",
"ContainerPort":80
}
]
}
],
"RequiresCompatibilities":[ "FARGATE" ],
"NetworkMode":"awsvpc",
"Cpu":"256",
"Memory":"512",
"Family":"ecs-demo"
}
},
"ECSDemoCluster":{
"Type":"AWS::ECS::Cluster",
"Properties":{}
},
"ECSDemoService":{
"Type":"AWS::ECS::Service",
"Properties":{
"Cluster":{ "Ref":"ECSDemoCluster" },
"DesiredCount":1,
"DeploymentController":{ "Type":"EXTERNAL" }
}
},
"BlueTaskSet":{
"Type":"AWS::ECS::TaskSet",
"Properties":{
"Cluster":{ "Ref":"ECSDemoCluster" },
"LaunchType":"FARGATE",
"NetworkConfiguration":{
"AwsVpcConfiguration":{
"AssignPublicIp":"ENABLED",
"SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
"Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }]
}
},
"PlatformVersion":"1.4.0",
"Scale":{
"Unit":"PERCENT",
"Value":100
},
"Service":{ "Ref":"ECSDemoService"},
"TaskDefinition":{ "Ref":"BlueTaskDefinition" },
"LoadBalancers":[
{
"ContainerName":"DemoApp",
"ContainerPort":80,
"TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" }
}
]
}
},
"PrimaryTaskSet":{
"Type":"AWS::ECS::PrimaryTaskSet",
"Properties":{
"Cluster":{ "Ref":"ECSDemoCluster" },
"Service":{ "Ref":"ECSDemoService" },
"TaskSetId":{ "Fn::GetAtt":[ "BlueTaskSet","Id" ]
}
}
}
}
}
```
## YAML
```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
Vpc:
Type: AWS::EC2::VPC::Id
Subnet1:
Type: AWS::EC2::Subnet::Id
Subnet2:
Type: AWS::EC2::Subnet::Id
Transform:
- 'AWS::CodeDeployBlueGreen'
Hooks:
CodeDeployBlueGreenHook:
Type: AWS::CodeDeploy::BlueGreen
Properties:
TrafficRoutingConfig:
Type: TimeBasedCanary
TimeBasedCanary:
StepPercentage: 15
BakeTimeMins: 5
Applications:
- Target:
Type: AWS::ECS::Service
LogicalID: ECSDemoService
ECSAttributes:
TaskDefinitions:
- BlueTaskDefinition
- GreenTaskDefinition
TaskSets:
- BlueTaskSet
- GreenTaskSet
TrafficRouting:
ProdTrafficRoute:
Type: AWS::ElasticLoadBalancingV2::Listener
LogicalID: ALBListenerProdTraffic
TargetGroups:
- ALBTargetGroupBlue
- ALBTargetGroupGreen
Resources:
ExampleSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for ec2 access
VpcId: !Ref Vpc
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 8080
ToPort: 8080
CidrIp: 0.0.0.0/0
- IpProtocol: tcp
FromPort: 22
ToPort: 22
CidrIp: 0.0.0.0/0
ALBTargetGroupBlue:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
HealthCheckIntervalSeconds: 5
HealthCheckPath: /
HealthCheckPort: '80'
HealthCheckProtocol: HTTP
HealthCheckTimeoutSeconds: 2
HealthyThresholdCount: 2
Matcher:
HttpCode: '200'
Port: 80
Protocol: HTTP
Tags:
- Key: Group
Value: Example
TargetType: ip
UnhealthyThresholdCount: 4
VpcId: !Ref Vpc
ALBTargetGroupGreen:
Type: AWS::ElasticLoadBalancingV2::TargetGroup
Properties:
HealthCheckIntervalSeconds: 5
HealthCheckPath: /
HealthCheckPort: '80'
HealthCheckProtocol: HTTP
HealthCheckTimeoutSeconds: 2
HealthyThresholdCount: 2
Matcher:
HttpCode: '200'
Port: 80
Protocol: HTTP
Tags:
- Key: Group
Value: Example
TargetType: ip
UnhealthyThresholdCount: 4
VpcId: !Ref Vpc
ExampleALB:
Type: AWS::ElasticLoadBalancingV2::LoadBalancer
Properties:
Scheme: internet-facing
SecurityGroups:
- !Ref ExampleSecurityGroup
Subnets:
- !Ref Subnet1
- !Ref Subnet2
Tags:
- Key: Group
Value: Example
Type: application
IpAddressType: ipv4
ALBListenerProdTraffic:
Type: AWS::ElasticLoadBalancingV2::Listener
Properties:
DefaultActions:
- Type: forward
ForwardConfig:
TargetGroups:
- TargetGroupArn: !Ref ALBTargetGroupBlue
Weight: 1
LoadBalancerArn: !Ref ExampleALB
Port: 80
Protocol: HTTP
ALBListenerProdRule:
Type: AWS::ElasticLoadBalancingV2::ListenerRule
Properties:
Actions:
- Type: forward
ForwardConfig:
TargetGroups:
- TargetGroupArn: !Ref ALBTargetGroupBlue
Weight: 1
Conditions:
- Field: http-header
HttpHeaderConfig:
HttpHeaderName: User-Agent
Values:
- Mozilla
ListenerArn: !Ref ALBListenerProdTraffic
Priority: 1
ECSTaskExecutionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Sid: ''
Effect: Allow
Principal:
Service: ecs-tasks.amazonaws.com
Action: 'sts:AssumeRole'
ManagedPolicyArns:
- 'arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy'
BlueTaskDefinition:
Type: AWS::ECS::TaskDefinition
Properties:
ExecutionRoleArn: !GetAtt
- ECSTaskExecutionRole
- Arn
ContainerDefinitions:
- Name: DemoApp
Image: 'nginxdemos/hello:latest'
Essential: true
PortMappings:
- HostPort: 80
Protocol: tcp
ContainerPort: 80
RequiresCompatibilities:
- FARGATE
NetworkMode: awsvpc
Cpu: '256'
Memory: '512'
Family: ecs-demo
ECSDemoCluster:
Type: AWS::ECS::Cluster
Properties: {}
ECSDemoService:
Type: AWS::ECS::Service
Properties:
Cluster: !Ref ECSDemoCluster
DesiredCount: 1
DeploymentController:
Type: EXTERNAL
BlueTaskSet:
Type: AWS::ECS::TaskSet
Properties:
Cluster: !Ref ECSDemoCluster
LaunchType: FARGATE
NetworkConfiguration:
AwsVpcConfiguration:
AssignPublicIp: ENABLED
SecurityGroups:
- !Ref ExampleSecurityGroup
Subnets:
- !Ref Subnet1
- !Ref Subnet2
PlatformVersion: 1.4.0
Scale:
Unit: PERCENT
Value: 100
Service: !Ref ECSDemoService
TaskDefinition: !Ref BlueTaskDefinition
LoadBalancers:
- ContainerName: DemoApp
ContainerPort: 80
TargetGroupArn: !Ref ALBTargetGroupBlue
PrimaryTaskSet:
Type: AWS::ECS::PrimaryTaskSet
Properties:
Cluster: !Ref ECSDemoCluster
Service: !Ref ECSDemoService
TaskSetId: !GetAtt
- BlueTaskSet
- Id
```