Rifattorizzazione degli stack

Il refactoring dello stack semplifica la riorganizzazione delle risorse negli stack preservando al contempo le proprietà e i dati delle risorse esistenti. CloudFormation Con il refactoring dello stack, puoi spostare le risorse tra gli stack, dividere gli stack monolitici in componenti più piccoli o consolidare più stack in uno solo.

Come funziona lo stack refactoring

Prendi in considerazione i passaggi seguenti quando pianifichi il refactor dello stack:

1. Valuta la tua infrastruttura attuale: esamina gli CloudFormation stack e le risorse esistenti per identificare le opportunità di refactoring degli stack.

2. Pianifica il refactoring: definisci come devono essere organizzate le risorse. Considerate le vostre dipendenze, le convenzioni di denominazione e i limiti operativi. Questi possono influire sulla convalida successiva CloudFormation .

   Determina il numero di stack di destinazione in cui rifattorizzerai le risorse. Puoi spostare le risorse tra almeno 2 pile e un massimo di 5 pile. Le risorse possono essere spostate tra pile annidate.

3. Aggiorna i modelli: modifica i CloudFormation modelli in modo che riflettano la modifica pianificata, ad esempio spostando le definizioni delle risorse tra i modelli. È possibile rinominare il codice logico IDs durante il refactoring.

4. Crea il refactor dello stack: fornisci un elenco di nomi e modelli dello stack che desideri rifattorizzare.

5. Esamina l'impatto del refactoring sulla tua infrastruttura e risolvi eventuali conflitti: CloudFormation convalida i modelli forniti e verifica le dipendenze tra gli stack, i tipi di risorse con problemi di aggiornamento dei tag e i conflitti tra gli ID logici delle risorse.

   Se la convalida ha esito positivo, CloudFormation genererà un'anteprima delle azioni di rifattore che avverranno dopo l'esecuzione del refactor.

   Se la convalida fallisce, puoi riprovare dopo aver risolto i problemi rilevati. In caso di conflitti, sarà necessario fornire una mappatura degli ID logici delle risorse che mostri l'origine e la destinazione della risorsa in conflitto.

6. Esegui il refactoring: dopo aver verificato che le modifiche siano in linea con il modo in cui desideri rifattorizzare gli stack, esegui lo stack refactor.

7. Monitora: controlla lo stato dello stack refactor ExecutionStatus per assicurarti che abbia esito positivo.

Limitazioni dello stack refactoring

Considerate le seguenti limitazioni quando pianificate il refactoring dello stack:

• Le operazioni di rifattorizzazione non consentono la creazione di nuove risorse, l'eliminazione di risorse o la modifica delle configurazioni delle risorse.

• Non è possibile modificare o aggiungere nuovi parametri, condizioni o mappature durante un refactoring dello stack. Una possibile soluzione alternativa consiste nell'aggiornare lo stack prima di eseguire il refactoring.

• Non puoi rifattorizzare la stessa risorsa in più stack.

• Non è possibile rifattorizzare una risorsa in un nuovo stack se quello stack utilizza determinati pseudo parametri (Esempio:). AWS::StackName

• CloudFormation non supporta pile vuote. Prima di creare un refactor dello stack che rimuova tutte le risorse esistenti da uno stack, è necessario aggiungere una risorsa a quello stack. Questa risorsa può essere semplice, ad esempio un tipo di risorsa. waitCondition

• Stack refactor non supporta gli stack che contengono policy di stack, incluse le policy che consentono la modifica delle risorse.

• Le seguenti risorse non sono disponibili:

  • AWS::ACMPCA::Certificate

  • AWS::ACMPCA::CertificateAuthority

  • AWS::ACMPCA::CertificateAuthorityActivation

  • AWS::ApiGateway::BasePathMapping

  • AWS::ApiGateway::Method

  • AWS::AppConfig::ConfigurationProfile

  • AWS::AppConfig::Deployment

  • AWS::AppConfig::Environment

  • AWS::AppConfig::Extension

  • AWS::AppConfig::ExtensionAssociation

  • AWS::AppStream::DirectoryConfig

  • AWS::AppStream::StackFleetAssociation

  • AWS::AppStream::StackUserAssociation

  • AWS::AppStream::User

  • AWS::BackupGateway::Hypervisor

  • AWS::CodePipeline::CustomActionType

  • AWS::Cognito::UserPoolRiskConfigurationAttachment

  • AWS::Cognito::UserPoolUICustomizationAttachment

  • AWS::Cognito::UserPoolUserToGroupAttachment

  • AWS::Config::ConfigRule

  • AWS::DataBrew::Dataset

  • AWS::DataBrew::Job

  • AWS::DataBrew::Project

  • AWS::DataBrew::Recipe

  • AWS::DataBrew::Ruleset

  • AWS::DataBrew::Schedule

  • AWS::DataZone::DataSource

  • AWS::DataZone::Environment

  • AWS::DataZone::EnvironmentBlueprintConfiguration

  • AWS::DataZone::EnvironmentProfile

  • AWS::DataZone::Project

  • AWS::DataZone::SubscriptionTarget

  • AWS::DynamoDB::GlobalTable

  • AWS::EC2::LaunchTemplate

  • AWS::EC2::SpotFleet

  • AWS::EC2::VolumeAttachment

  • AWS::EC2::VPCDHCPOptionsAssociation

  • AWS::ElasticBeanstalk::ConfigurationTemplate

  • AWS::FIS::ExperimentTemplate

  • AWS::Glue::Schema

  • AWS::GuardDuty::IPSet

  • AWS::GuardDuty::PublishingDestination

  • AWS::GuardDuty::ThreatIntelSet

  • AWS::ImageBuilder::Component

  • AWS::IoTFleetWise::Campaign

  • AWS::IoTWireless::WirelessDeviceImportTask

  • AWS::Lambda::EventInvokeConfig

  • AWS::Lex::BotVersion

  • AWS::M2::Application

  • AWS::Maester::DocumentType

  • AWS::MediaTailor::Channel

  • AWS::MSK::Configuration

  • AWS::MSK::ServerlessCluster

  • AWS::NeptuneGraph::PrivateGraphEndpoint

  • AWS::Omics::AnnotationStore

  • AWS::Omics::ReferenceStore

  • AWS::Omics::SequenceStore

  • AWS::OpenSearchServerless::Collection

  • AWS::Panorama::PackageVersion

  • AWS::PCAConnectorAD::Connector

  • AWS::PCAConnectorAD::DirectoryRegistration

  • AWS::PCAConnectorAD::Template

  • AWS::PCAConnectorAD::TemplateGroupAccessControlEntry

  • AWS::QuickSight::Theme

  • AWS::RefactorSpaces::Environment

  • AWS::RefactorSpaces::Route

  • AWS::RefactorSpaces::Service

  • AWS::RoboMaker::RobotApplication

  • AWS::RoboMaker::SimulationApplication

  • AWS::SageMaker::InferenceComponen

  • AWS::ServiceCatalog::PortfolioPrincipalAssociation

  • AWS::ServiceCatalog::PortfolioProductAssociation

  • AWS::ServiceCatalog::PortfolioShare

  • AWS::ServiceCatalog::TagOptionAssociation

  • AWS::ServiceCatalogAppRegistry::AttributeGroupAssociation

  • AWS::ServiceCatalogAppRegistry::ResourceAssociation

  • AWS::StepFunctions::StateMachineVersion

  • AWS::Synthetics::Canary

  • AWS::VoiceID::Domain

  • AWS::WAFv2::IPSet

  • AWS::WAFv2::RegexPatternSet

  • AWS::WAFv2::RuleGroup

  • AWS::WAFv2::WebACL

Rifattorizzazione di uno stack utilizzando il AWS Command Line Interface

I seguenti comandi vengono utilizzati per il refactoring dello stack:

• create-stack-refactor

• describe-stack-refactor

• execute-stack-refactor

• list-stack-refactors

• list-stack-refactor-actions

Di seguito è riportato un esempio di come rifattorizzare uno stack utilizzando ( AWS Command Line Interface CLI).

1. Per iniziare, avrai bisogno del CloudFormation modello che desideri rifattorizzare. Il comando seguente recupera il modello:

   aws cloudformation get-template --stack-name ExampleStack1

   Una volta ottenuto il modello, utilizzate l'ambiente di sviluppo integrato (IDE) di vostra scelta per aggiornarlo in modo da utilizzare la struttura e l'organizzazione delle risorse desiderate.

2. Crea lo stack refactor usando il create-stack-refactor comando e fornisci il nome dello stack e i modelli per ogni stack coinvolto nel refactoring:

   aws cloudformation create-stack-refactor \
     --stack-definitions \
       StackName=MySns,TemplateBody@=file://afterSns.yaml \
       StackName=MyLambdaSubscription,TemplateBody@=file://afterLambda.yaml \
     --enable-stack-creation \ 
     --resource-mappings file://refactor.json
   

   Il --resource-mappings parametro è facoltativo, ma sarà necessario se viene rilevato un conflitto durante la convalida del modello. Oltre a fornire gli Destination stack Source and, dovrai fornire anche il. LogicalResourceId Di seguito è riportato un esempio del file refactor.json.

   [
       {
           "Source": {
               "StackName": "MySns",
               "LogicalResourceId": "MyFunction"
           },
           "Destination": {
               "StackName": "MyLambdaSubscription",
               "LogicalResourceId": "Function"
           }
       }
   ]

3. Dopo aver creato il refactor, CloudFormation genera un'anteprima della modifica del refactor, che consente di visualizzare in anteprima l'impatto che le modifiche proposte avranno sull'infrastruttura. In questo esempio, il file StackRefactorId creato è. stack-refactor-1ab2-c34d-5ef6 Utilizzate il seguente comando per visualizzare in anteprima le modifiche:

   aws cloudformation list-stack-refactor-actions \
     --stack-refactor-id stack-refactor-1ab2-c34d-5ef6

4. Dopo aver esaminato e confermato le modifiche, utilizzate il execute-stack-refactor comando per completare il processo di refactoring:

   aws cloudformation execute-stack-refactor \
     --stack-refactor-id stack-refactor-1ab2-c34d-5ef6

5. Dopo l'esecuzioneexecute-stack-refactor, è possibile monitorare lo stato dell'operazione utilizzando il seguente comando:

   aws cloudformation describe-stack-refactor \
     --stack-refactor-id stack-refactor-1ab2-c34d-5ef6

   CloudFormation aggiornerà automaticamente la Status fine ExecutionStatus dell'operazione di refactor.