Utwórz potok CI/CD dla funkcji .NET Lambda za pomocą potoków AWS CDK

AWS Cloud Development Kit (AWS CDK) to platforma programistyczna typu open source do definiowania infrastruktury chmury w znanych językach programowania i udostępniania jej za pośrednictwem AWS CloudFormation.

Poniższy artykuł posłuży do zbadania procesu tworzenia potoku ciągłej integracji/ciągłego wdrażania (CI/CD) dla funkcji .NET AWS Lambda przy użyciu potoków CDK. Autorzy omówią wszystkie niezbędne kroki do zautomatyzowania wdrożenia funkcji .NET Lambda, w tym konfigurację środowiska programistycznego, utworzenie potoku z AWS CDK, skonfigurowanie etapów potoku i opublikowanie raportów z testów. Dodatkowo pokażą, jak promować wdrożenie z niższego środowiska do wyższego środowiska z ręcznym zatwierdzaniem.

Kontekst

AWS CDK ułatwia wdrażanie stosu, który dostarcza infrastrukturę do AWS ze stacji roboczej, po prostu uruchamiając cdk Deploy. Jest to przydatne podczas wstępnego programowania i testowania. Jednak w większości rzeczywistych scenariuszy istnieje wiele środowisk, takich jak programowanie, testowanie, przemieszczanie i produkcja. Wdrażanie aplikacji CDK we wszystkich tych środowiskach przy użyciu narzędzia cdk może nie być najlepszym podejściem. Wdrożenie w tych środowiskach powinno odbywać się za pośrednictwem bardziej niezawodnych, zautomatyzowanych potoków. CDK Pipelines ułatwia skonfigurowanie potoku ciągłego wdrażania dla aplikacji CDK, obsługiwanych przez AWS CodePipeline.

Strona AWS CDK Developer Guide's Continuous Integration and Delivery (CI/CD) using CDK Pipelines pokazuje, jak można używać CDK Pipelines do wdrażania funkcji Lambda opartej na Node.js. Jednak funkcje Lambda oparte na .NET różnią się od funkcji Lambda opartych na Node.js lub Python, ponieważ kod .NET musi zostać najpierw skompilowany w celu utworzenia pakietu wdrożeniowego. W rezultacie zdecydowano się napisać ten artykuł jako rodzaj przewodnika krok po kroku, aby pomóc klientom .NET we wdrażaniu ich funkcji Lambda przy użyciu potoków CDK.

W tym artykule razem z autorami zagłębisz się w tworzenie rzeczywistego potoku, który uruchamia kompilację i testy jednostkowe oraz wdraża funkcję .NET Lambda w jednym lub wielu środowiskach.

Architektura

CDK Pipelines to biblioteka konstrukcji, która umożliwia udostępnianie potoku CodePipeline. Potok utworzony przez potoki CDK sam się mutuje. Oznacza to, że aby uruchomić potok, musisz raz uruchomić cdk. Następnie potok automatycznie aktualizuje się, jeśli dodasz nowe etapy aplikacji lub stosy w kodzie źródłowym.

Na poniższym diagramie przedstawiono architekturę potoku CI/CD utworzonego za pomocą potoków CDK. Przyjrzyj się tej architekturze na wysokim poziomie, zanim zagłębisz się w szczegóły.

Rozwiązanie tworzy CodePipeline z repozytorium AWS CodeCommit jako źródłem (CodePipeline Source Stage). Kiedy kod jest zaewidencjonowany w CodeCommit, potok jest automatycznie uruchamiany i pobiera kod z gałęzi repozytorium CodeCommit, aby przejść do etapu kompilacji.

• Etap Kompiluj kompiluje kod aplikacji CDK i generuje zespół w chmurze.
• Etap Aktualizuj potok aktualizuje potok (w razie potrzeby).
• Etap Publikuj zasoby przesyła zasoby CDK do Amazon S3.

Po zakończeniu publikowania zasobów potok wdraża funkcję Lambda zarówno w środowisku programistycznym, jak i produkcyjnym. Aby zapewnić dodatkową kontrolę, architektura obejmuje etap ręcznego zatwierdzania wersji przeznaczonych dla środowiska produkcyjnego.

Warunki wstępne

Do tego samouczka powinieneś posiadać:

1. Konto AWS
2. Visual Studio 2022
3. AWS Toolkit for Visual Studio
4. Node.js 18.x or later
5. AWS CDK v2 (2.67.0 or later required)
6. Git

Bootstrapping

Zanim użyjesz AWS CDK do wdrożenia potoków CDK, musisz załadować środowiska AWS, w których chcesz wdrożyć funkcję Lambda. Środowisko to docelowe konto AWS i region, w którym stos ma zostać wdrożony.

W tym poście wdrażasz funkcję Lambda w środowisku programistycznym i opcjonalnie w środowisku produkcyjnym. Wymaga to załadowania obu środowisk. Jednak wdrożenie w środowisku produkcyjnym jest opcjonalne; możesz na razie pominąć ładowanie tego środowiska, ponieważ autorzy zajmą się tym później.

Jest to jednorazowa czynność na środowisko dla każdego środowiska, w którym chcesz wdrożyć aplikacje CDK. Aby uruchomić środowisko programistyczne, uruchom poniższe polecenie, zastępując identyfikator konta AWS kontem deweloperskim, regionem, którego będziesz używać w środowisku programistycznym oraz lokalnie skonfigurowanym profilem AWS CLI, którego chcesz używać dla tego konta. Dodatkowe informacje znajdują się w dokumentacji.

BASH

cdk bootstrap aws://<DEV-ACCOUNT-ID>/<DEV-REGION> \
    --profile DEV-PROFILE \ 
    --cloudfor

-‐profile określa profil poświadczeń AWS CLI, który będzie używany do organizowania środowiska. Jeśli nie zostanie określony, zostanie użyty profil domyślny. Profil powinien mieć wystarczające uprawnienia do udostępniania zasobów dla AWS CDK podczas procesu organizowania początkowego.

‐‐cloudformation-execution-policies określa ARN zarządzanych zasad, które powinny być dołączone do roli wdrożenia przyjętej przez AWS CloudFormation podczas wdrażania twoich stosów.

Uwaga: Domyślnie stosy są wdrażane z pełnymi uprawnieniami administratora przy użyciu zasad Dostępu administratora, ale do rzeczywistego użytku należy zdefiniować bardziej restrykcyjne zasady IAM i używać ich, customizing bootstrapping in AWS CDK documentation i Secure CDK deployments with IAM permission boundaries, aby zobaczyć, jak to zrobić.

Utwórz repozytorium Git w AWS CodeCommit

W tym artykule użyjesz CodeCommit do przechowywania kodu źródłowego. Najpierw utwórz repozytorium git o nazwie dotnet-lambda-cdk-pipeline w CodeCommit, wykonując następujące kroki w dokumentacji CodeCommit.

Po utworzeniu repozytorium wygeneruj poświadczenia git, aby uzyskać dostęp do repozytorium z komputera lokalnego, jeśli jeszcze ich nie masz. Wykonaj poniższe czynności, aby wygenerować poświadczenia git.

1. Zaloguj się do konsoli zarządzania AWS i otwórz konsolę IAM.
2. Utwórz użytkownika IAM (na przykład git-user).
3. Po utworzeniu użytkownika dołącz do niego politykę AWSCodeCommitPowerUser.
4. Dalej. otwórz stronę szczegółów użytkownika, wybierz zakładkę Security Credentials, a w HTTPS Git credentials for AWS CodeCommit wybierz Generate.
5. Pobierz poświadczenia, aby pobrać te informacje jako plik .CSV.

Sklonuj ostatnio utworzone repozytorium na swoją stację roboczą, a następnie cd do katalogu dotnet-lambda-cdk-pipeline.

GIT

git clone 
cd dotnet-lambda-cdk-pipeline

Alternatywnie możesz użyć polecenia git-remote-codecommit do sklonowania repozytorium za pomocą polecenia git clone codecommit::://@, zastępując symbole zastępcze ich oryginalnymi wartościami. Używanie git-remote-codecommit nie wymaga tworzenia dodatkowych użytkowników IAM do zarządzania poświadczeniami git. Aby dowiedzieć się więcej, zapoznaj się ze stroną dokumentacji AWS CodeCommit z git-remote-codecommit.

Zainicjuj projekt CDK

W wierszu polecenia w katalogu dotnet-lambda-cdk-pipeline zainicjuj projekt AWS CDK, uruchamiając następujące polecenie.

Git

cdk init app --language csharp

Otwórz wygenerowane rozwiązanie C# w programie Visual Studio, kliknij prawym przyciskiem myszy projekt DotnetLambdaCdkPipeline i wybierz polecenie Właściwości. Ustaw platformę docelową na platformę .NET 6.

Utwórz stos CDK, aby udostępnić CodePipeline

Twoja aplikacja CDK Pipelines zawiera co najmniej dwa stosy: jeden reprezentujący sam potok i jeden lub więcej stosów reprezentujących aplikacje wdrożone za pośrednictwem potoku. W tym kroku tworzysz pierwszy stos, który wdraża potok CodePipeline na Twoim koncie AWS.

W programie Visual Studio otwórz rozwiązanie, otwierając plik rozwiązania .sln (w folderze src/). Po załadowaniu rozwiązania otwórz plik DotnetLambdaCdkPipelineStack.cs i zastąp jego zawartość następującym kodem. Zauważ, że nazwa pliku, przestrzeń nazw i nazwa klasy zakładają, że nazwałeś swoje repozytorium Git, jak pokazano wcześniej.

Uwaga: pamiętaj, aby zastąpić „” w poniższym kodzie nazwą swojego repozytorium CodeCommit (w tym poście na blogu użyto dotnet-lambda-cdk-pipeline).

C#

using Amazon.CDK;
using Amazon.CDK.AWS.CodeBuild;
using Amazon.CDK.AWS.CodeCommit;
using Amazon.CDK.AWS.IAM;
using Amazon.CDK.Pipelines;
using Constructs;
using System.Collections.Generic;

namespace DotnetLambdaCdkPipeline 
{
    public class DotnetLambdaCdkPipelineStack : Stack
    {
        internal DotnetLambdaCdkPipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
    
            var repository = Repository.FromRepositoryName(this, "repository", "");
    
            // This construct creates a pipeline with 3 stages: Source, Build, and UpdatePipeline
            var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
            {
                PipelineName = "LambdaPipeline",
                SelfMutation = true,
    
                // Synth represents a build step that produces the CDK Cloud Assembly.
                // The primary output of this step needs to be the cdk.out directory generated by the cdk synth command.
                Synth = new CodeBuildStep("Synth", new CodeBuildStepProps
                {
                    // The files downloaded from the repository will be placed in the working directory when the script is executed
                    Input = CodePipelineSource.CodeCommit(repository, "master"),
    
                    // Commands to run to generate CDK Cloud Assembly
                    Commands = new string[] { "npm install -g aws-cdk", "cdk synth" },
    
                    // Build environment configuration
                    BuildEnvironment = new BuildEnvironment
                    {
                        BuildImage = LinuxBuildImage.AMAZON_LINUX_2_4,
                        ComputeType = ComputeType.MEDIUM,
    
                        // Specify true to get a privileged container inside the build environment image
                        Privileged = true
                    }
                })
            });
        }
    }
}

W powyższym kodzie używasz CodeBuildStep zamiast ShellStep, ponieważ ShellStep nie udostępnia właściwości do określenia BuildEnvironment. Musisz określić środowisko kompilacji, aby ustawić tryb uprzywilejowany, który umożliwia dostęp do demona Dockera w celu zbudowania obrazów kontenerów w środowisku kompilacji. Jest to konieczne do korzystania z funkcji łączenia CDK, co wyjaśniono w dalszej części tego artykułu.

Otwórz plik src/DotnetLambdaCdkPipeline/Program.cs i edytuj jego zawartość, aby odzwierciedlić poniższe. Pamiętaj, aby zastąpić symbole zastępcze identyfikatorem konta AWS i regionem dla środowiska deweloperskiego.

C#

using Amazon.CDK;

namespace DotnetLambdaCdkPipeline
{
    sealed class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new DotnetLambdaCdkPipelineStack(app, "DotnetLambdaCdkPipelineStack", new StackProps
            {
                Env = new Amazon.CDK.Environment
                {
                    Account = "",
                    Region = ""
                }
            });
            app.Synth();
        }
    }
}

Uwaga: Zamiast zatwierdzać identyfikator konta i region do kontroli źródła, możesz ustawić zmienne środowiskowe w agencie CodeBuild i użyć ich; zobacz Środowiska w dokumentacji AWS CDK, aby uzyskać więcej informacji. Ponieważ agent CodeBuild jest również skonfigurowany w twoim kodzie CDK, możesz użyć właściwości BuildEnvironmentVariableType do przechowywania zmiennych środowiskowych w AWS Systems Manager Parameter Store lub AWS Secrets Manager.

Po wprowadzeniu zmian w kodzie Skompiluj rozwiązanie, aby upewnić się, że nie występują problemy z kompilacją. Następnie zatwierdź i wypchnij wszystkie zmiany, które właśnie wprowadziłeś. Uruchom następujące polecenia (lub alternatywnie użyj wbudowanej funkcji Git programu Visual Studio, aby zatwierdzić i wypchnąć zmiany):

Git

git add --all .
git commit -m 'Initial commit'
git push

Następnie przejdź do katalogu głównego repozytorium, w którym znajduje się plik cdk.json, i uruchom polecenie cdk wdrażania, aby wdrożyć początkową wersję CodePipeline. Pamiętaj, że wdrożenie może potrwać kilka minut.

Potok stworzony przez CDK Pipelines sam się mutuje. Oznacza to, że aby uruchomić potok, wystarczy jednorazowo uruchomić program cdk. Następnie potok automatycznie aktualizuje się, jeśli dodasz nowe aplikacje CDK lub etapy w kodzie źródłowym.

Po zakończeniu wdrażania zostanie utworzony i automatycznie uruchomiony CodePipeline. Potok obejmuje trzy etapy, jak pokazano poniżej.

• Źródło – pobiera źródło Twojej aplikacji AWS CDK z repozytorium CodeCommit i uruchamia potok za każdym razem, gdy wysyłasz do niego nowe zatwierdzenia.
• Build – Ten etap kompiluje twój kod (jeśli to konieczne) i wykonuje syntezator cdk. Dane wyjściowe tego kroku to zestaw w chmurze.
• UpdatePipeline – na tym etapie uruchamiane jest polecenie cdk Deploy na zespole chmury wygenerowanym w poprzednim etapie. W razie potrzeby modyfikuje potok. Na przykład jeśli zaktualizujesz swój kod, aby dodać nowy etap wdrażania do potoku aplikacji, potok zostanie automatycznie zaktualizowany w celu odzwierciedlenia wprowadzonych zmian.

Zdefiniuj etap CodePipeline, aby wdrożyć funkcję .NET Lambda

W tym kroku tworzysz stos zawierający prostą funkcję Lambda i umieszczasz ten stos na scenie. Następnie dodasz etap do potoku, aby można go było wdrożyć.

Aby utworzyć projekt Lambda, wykonaj następujące czynności:

1. W Visual Studio kliknij prawym przyciskiem myszy rozwiązanie, wybierz Dodaj, a następnie wybierz Nowy projekt.
2. W oknie New Project wybierz szablon AWS Lambda Project (.NET Core – C#), a następnie wybierz OK lub Next.
3. W polu Nazwa projektu wpisz SampleLambda, a następnie wybierz opcję Utwórz.
4. W oknie dialogowym Select Blueprint wybierz opcję Empty Function, a następnie wybierz Finish.

Następnie utwórz nowy plik w projekcie CDK w src/DotnetLambdaCdkPipeline/SampleLambdaStack.cs, aby zdefiniować stos aplikacji zawierający funkcję Lambda. Zaktualizuj plik o następującą zawartość (w razie potrzeby dostosuj przestrzeń nazw):

C#

using Amazon.CDK;
using Amazon.CDK.AWS.Lambda;
using Constructs;
using AssetOptions = Amazon.CDK.AWS.S3.Assets.AssetOptions;

namespace DotnetLambdaCdkPipeline 
{
    class SampleLambdaStack: Stack
    {
        public SampleLambdaStack(Construct scope, string id, StackProps props = null) : base(scope, id, props)
        {
            // Commands executed in a AWS CDK pipeline to build, package, and extract a .NET function.
            var buildCommands = new[]
            {
                "cd /asset-input",
                "export DOTNET_CLI_HOME=\"/tmp/DOTNET_CLI_HOME\"",
                "export PATH=\"$PATH:/tmp/DOTNET_CLI_HOME/.dotnet/tools\"",
                "dotnet build",
                "dotnet tool install -g Amazon.Lambda.Tools",
                "dotnet lambda package -o output.zip",
                "unzip -o -d /asset-output output.zip"
            };
                
            new Function(this, "LambdaFunction", new FunctionProps
            {
                Runtime = Runtime.DOTNET_6,
                Handler = "SampleLambda::SampleLambda.Function::FunctionHandler",
    
                // Asset path should point to the folder where .csproj file is present.
                // Also, this path should be relative to cdk.json file.
                Code = Code.FromAsset("./src/SampleLambda", new AssetOptions
                {
                    Bundling = new BundlingOptions
                    {
                        Image = Runtime.DOTNET_6.BundlingImage,
                        Command = new[]
                        {
                            "bash", "-c", string.Join(" && ", buildCommands)
                        }
                    }
                })
            });
        }
    }
}

Budowanie wewnątrz kontenera Docker

Powyższy kod używa funkcji łączenia w celu zbudowania funkcji Lambda w kontenerze dokera. Bundling uruchamia nowy kontener dokera, kopiuje kod źródłowy Lambda do katalogu /asset-input kontenera, uruchamia określone polecenia, które zapisują pliki pakietu w katalogu /asset-output. Pliki w /asset-output są kopiowane jako zasoby do katalogu zestawu w chmurze stosu. Na późniejszym etapie pliki te są spakowane i przesłane do S3 jako zasób CDK.

Budowanie funkcji Lambda w kontenerach Dockera jest lepsze niż budowanie ich lokalnie, ponieważ zmniejsza zależności maszyny hosta, co skutkuje większą spójnością i niezawodnością procesu kompilacji.

Bundling wymaga utworzenia kontenera dokera na maszynie kompilacji. W tym celu ustawienie uprzywilejowane: true na maszynie budującej zostało już skonfigurowane.

Dodanie etapu rozwoju

Utwórz nowy plik w projekcie CDK w src/DotnetLambdaCdkPipeline/DotnetLambdaCdkPipelineStage.cs, aby wstrzymać etap. Ta klasa utworzy etap rozwoju potoku.

Edytuj plik src/DotnetLambdaCdkPipeline/DotnetLambdaCdkPipelineStack.cs, aby dodać etap do potoku. Dodaj pogrubioną linię z poniższego kodu do swojego pliku.

Następnie skompiluj rozwiązanie, a następnie zatwierdź i puść zmiany do repozytorium CodeCommit. Spowoduje to uruchomienie CodePipeline.

Po uruchomieniu potoku etap UpdatePipeline wykrywa zmiany i aktualizuje potok na podstawie znalezionego tam kodu. Po zakończeniu etapu UpdatePipeline potok jest aktualizowany o dodatkowe etapy.

Pora zaobserwować zmiany:

1. Dodano etap zasobów. Na tym etapie wszystkie zasoby, których używasz w swojej aplikacji, są przesyłane do Amazon S3 (zasobnik S3 utworzony podczas ładowania początkowego), aby mogły być używane na innych etapach wdrażania w dalszej części potoku. Na przykład szablon CloudFormation używany na etapie opracowywania zawiera odniesienia do tych zasobów, dlatego zasoby są najpierw przenoszone do S3, a następnie przywoływane w późniejszych etapach.
2. Dodano etap rozwoju z dwiema akcjami. Pierwszą czynnością jest utworzenie zbioru zmian, a drugą jego wykonanie.

Po zakończeniu etapu Deploy możesz znaleźć nowo wdrożoną funkcję Lambda, odwiedzając konsolę Lambda, wybierając „Funkcje” z lewego menu i filtrując listę funkcji za pomocą „LambdaStack”. Uwaga: środowisko uruchomieniowe to .NET.

Uruchamianie przypadków testów jednostkowych w CodePipeline

Następnie dodasz jednostkowe przypadki testowe do swojej funkcji Lambda i uruchomisz je w potoku, aby wygenerować raport z testu w CodeBuild.

Aby utworzyć projekt testu jednostkowego, wykonaj następujące czynności:

1. Kliknij prawym przyciskiem myszy rozwiązanie, wybierz Dodaj, a następnie wybierz Nowy projekt.
2. W oknie dialogowym Nowy projekt wybierz szablon projektu testowego xUnit, a następnie wybierz OK lub Dalej.
3. W polu Nazwa projektu wpisz SampleLambda.Tests, a następnie wybierz opcję Utwórz lub Dalej.
4. W zależności od używanej wersji programu Visual Studio może zostać wyświetlony monit o wybranie używanej wersji platformy .NET. Wybierz platformę .NET 6,0 (wsparcie długoterminowe), a następnie wybierz pozycję Utwórz.
5. Kliknij prawym przyciskiem myszy na projekt SampleLambda.Tests, wybierz Add, a następnie wybierz Project Reference. Wybierz projekt SampleLambda, a następnie wybierz przycisk OK.

Następnie edytuj plik src/SampleLambda.Tests/UnitTest1.cs, aby dodać test jednostkowy. Możesz użyć poniższego kodu, który sprawdza, czy funkcja Lambda zwraca ciąg wejściowy jako wielkie litery.

Możesz dodać działania przed wdrożeniem lub po wdrożeniu do etapu, wywołując jego metodę AddPre() lub AddPost(). Aby wykonać powyższe przypadki testowe, autorzy użyją akcji przed wdrożeniem.

Aby dodać akcję poprzedzającą wdrożenie, edytuj plik src/DotnetLambdaCdkPipeline/DotnetLambdaCdkPipelineStack.cs w projekcie CDK, po dodaniu kodu do generowania raportów z testów.

Aby uruchomić testy jednostkowe i opublikować raport z testów w CodeBuild, skonstruuj BuildSpec dla naszego projektu CodeBuild. Autorzy udostępniają również oświadczenia dotyczące zasad IAM, które należy dołączyć do roli usługi CodeBuild, przyznając jej uprawnienia do uruchamiania testów i tworzenia raportów. Zaktualizuj plik, dodając nowy kod (zaczynający się od „// Dodaj ten kod do raportów z testów”) pod dodaną wcześniej deklaracją devStage:

C#

using Amazon.CDK; 
using Amazon.CDK.Pipelines;
...

namespace DotnetLambdaCdkPipeline 
{
    public class DotnetLambdaCdkPipelineStack : Stack
    {
        internal DotnetLambdaCdkPipelineStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // ...
            // ...
            // ...
            var devStage = pipeline.AddStage(new DotnetLambdaCdkPipelineStage(this, "Development"));
            
            
            
            // Add this code for test reports
            var reportGroup = new ReportGroup(this, "TestReports", new ReportGroupProps
            {
                ReportGroupName = "TestReports"
            });
           
            // Policy statements for CodeBuild Project Role
            var policyProps = new PolicyStatementProps()
            {
                Actions = new string[] {
                    "codebuild:CreateReportGroup",
                    "codebuild:CreateReport",
                    "codebuild:UpdateReport",
                    "codebuild:BatchPutTestCases"
                },
                Effect = Effect.ALLOW,
                Resources = new string[] { reportGroup.ReportGroupArn }
            };
            
            // PartialBuildSpec in AWS CDK for C# can be created using Dictionary
            var reports = new Dictionary<string, object>()
            {
                {
                    "reports", new Dictionary<string, object>()
                    {
                        {
                            reportGroup.ReportGroupArn, new Dictionary<string,object>()
                            {
                                { "file-format", "VisualStudioTrx" },
                                { "files", "**/*" },
                                { "base-directory", "./testresults" }
                            }
                        }
                    }
                }
            };
            // End of new code block
        }
    }
}

Na koniec dodaj CodeBuildStep jako akcję przed wdrożeniem do etapu programowania z niezbędnymi CodeBuildStepProps do skonfigurowania raportów. Dodaj to po nowym kodzie dodanym powyżej.

C#

devStage.AddPre(new Step[]
{
    new CodeBuildStep("Unit Test", new CodeBuildStepProps
    {
        Commands= new string[]
        {
            "dotnet test -c Release ./src/SampleLambda.Tests/SampleLambda.Tests.csproj --logger trx --results-directory ./testresults",
        },
        PrimaryOutputDirectory = "./testresults",
        PartialBuildSpec= BuildSpec.FromObject(reports),
        RolePolicyStatements = new PolicyStatement[] { new PolicyStatement(policyProps) },
        BuildEnvironment = new BuildEnvironment
        {
            BuildImage = LinuxBuildImage.AMAZON_LINUX_2_4,
            ComputeType = ComputeType.MEDIUM
        }
    })
});

Skompiluj rozwiązanie, a następnie zatwierdź i przenieś zmiany do repozytorium. Wypchnięcie zmian wyzwala potok, uruchamia przypadki testowe i publikuje raport w konsoli CodeBuild. Aby wyświetlić raport, po zakończeniu potoku przejdź do TestReports w grupach raportów CodeBuild, jak pokazano poniżej.

Wdrażanie w środowisku produkcyjnym z ręcznym zatwierdzaniem

CDK Pipelines bardzo ułatwia wdrażanie dodatkowych etapów z różnymi kontami. Musisz zainicjować konta i regiony, w których chcesz wdrożyć i muszą one mieć relację zaufania dodaną do konta potoku.

Aby załadować dodatkowe środowisko produkcyjne, w którym aplikacje AWS CDK zostaną wdrożone przez potok, uruchom poniższe polecenie, podstawiając identyfikator konta AWS dla konta produkcyjnego, region, którego będziesz używać w środowisku produkcyjnym, profil AWS CLI do użycia z kontem prod i identyfikatorem konta AWS, na którym potok jest już wdrożony (konto, które uruchomiłeś na początku tego artykułu).

Bash

cdk bootstrap aws://<PROD-ACCOUNT-ID>/<PROD-REGION>
    --profile <PROD-PROFILE> \
    --cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess \
    --trust <PIPELINE-ACCOUNT-ID>

Opcja --trust wskazuje, które inne konto powinno mieć uprawnienia do wdrażania aplikacji AWS CDK w tym środowisku. W przypadku tej opcji określ identyfikator konta AWS potoku.

Użyj poniższego kodu, aby dodać nowy etap wdrożenia produkcyjnego z ręcznym zatwierdzaniem. Dodaj ten kod pod blokiem kodu „devStage.AddPre(...)” dodanym w poprzedniej sekcji i pamiętaj, aby zastąpić symbole zastępcze identyfikatorem konta AWS i regionem dla środowiska produkcyjnego.

C#

var prodStage = pipeline.AddStage(new DotnetLambdaCdkPipelineStage(this, "Production", new StageProps
{
    Env = new Environment
    {
        Account = "",
        Region = ""
    }
}), new AddStageOpts
{
    Pre = new[] { new ManualApprovalStep("PromoteToProd") }
});

Aby obsługiwać wdrażanie aplikacji CDK na innym koncie, zasobniki artefaktów muszą być zaszyfrowane, więc dodaj właściwość CrossAccountKeys do CodePipeline w górnej części pliku stosu potoku i ustaw wartość na true (zobacz pogrubioną linię we fragmencie kodu poniżej). Spowoduje to utworzenie klucza KMS dla zasobnika artefaktów, co pozwoli na wdrożenie wielu kont.

C#

var pipeline = new CodePipeline(this, "pipeline", new CodePipelineProps
{
   PipelineName = "LambdaPipeline",
   SelfMutation = true,
   CrossAccountKeys = true,
   EnableKeyRotation = true, //Enable KMS key rotation for the generated KMS keys
   
   // ...
}

Po zatwierdzeniu i wypchnięciu zmian do repozytorium do etapu produkcji potoku zostanie dodany nowy krok ręcznego zatwierdzania o nazwie PromoteToProd. Potok zatrzymuje się na tym etapie i oczekuje na ręczne zatwierdzenie, jak pokazano na zrzucie ekranu poniżej.

Po kliknięciu przycisku Review zostanie wyświetlone następujące okno dialogowe. W tym miejscu możesz zatwierdzić lub odrzucić i w razie potrzeby dodać komentarze.

Po zatwierdzeniu potok zostaje wznowiony, wykonuje pozostałe kroki i kończy wdrażanie w środowisku produkcyjnym.

Porządkowanie

Aby uniknąć przyszłych opłat, zaloguj się do konsoli AWS różnych kont, z których korzystałeś, przejdź do konsoli AWS CloudFormation regionów, w których wybrałeś wdrożenie, wybierz i kliknij Usuń na stosach utworzonych dla tego działania. Ewentualnie możesz usunąć stosy CloudFormation za pomocą polecenia zniszczenia cdk. Nie usunie to stosu CDKToolkit utworzonego przez polecenie ładowania początkowego. Jeśli chcesz to również usunąć, możesz to zrobić z konsoli AWS.

Wnioski

Na podstawie tego artykułu nauczyłeś się, jak używać potoków CDK do automatyzacji procesu wdrażania funkcji .NET Lambda. Intuicyjna i elastyczna architektura ułatwia skonfigurowanie potoku CI/CD obejmującego cały cykl życia aplikacji, od kompilacji i testowania po wdrożenie. Dzięki CDK Pipelines możesz usprawnić przepływ pracy programistycznej, zmniejszyć liczbę błędów i zapewnić spójne i niezawodne wdrożenia.

Aby uzyskać więcej informacji na temat potoków CDK i wszystkich sposobów, w jakie można z nich korzystać, zobacz dokumentację referencyjną potoków CDK.

Źródło: AWS