Lambda har en web-baserad text editor som du har förmodligen använt innan för att skriva dina funktioner. Det är bra för nybörjare att lära sig plattform, men det är inte det bästa sättet att gå om att hantera uppdateringar. Här är hur att spåra din Lambda-funktioner på Git.
Hur CI – /CD För Lambda Fungerar
Istället för att använda den manuella redaktör, bör du utveckla dina funktioner lokalt, engagera och driva på förändringar för att en Git-repo, och har CodePipeline hantera bygga och distribution för dig.
CodePipeline körs automatiskt när den känner av förändringar i din källa kontroll, och skickar förändringar över att CodeBuild (eller Jenkins) för att bygga. Detta är ett valfritt steg, du kan inte använda det för Lambda, men om du använder något som Maskin du behöver detta skede. Efter byggnad, förändringar skjuts till CodeDeploy, som sköter distributionen.
CodeDeploy kommer att automatiskt uppdatera din Lambda-funktioner och driva en ny version. För att göra införandet processen smidigare, det kan flytta trafiken successivt med ett alias, tills 100% av trafiken är riktad mot den nya funktionen.
För att hantera den faktiska användningen, CodeDeploy använder AWS är Serverlösa Ansökan Modell (SAM). SAM är en förlängning av CloudFormation, en infrastruktur-som-kod service. Det är i grunden en läsbar data-serialisering språk (YAML) mall som används för att hantera alla inställningar i samband med utbyggnaden av Lambda-funktioner och deras förutsättningar, och är en viktig del av att kunna distribuera endast använder koden.
Att Sätta Upp Källkontroll
Detta steg är ganska enkel. Du vill skapa ett nytt projekt katalog för att hålla alla din kod, och initiera den med Git. SAM mallen kommer att gå till roten av denna katalog, som heter mall.yml. Varje funktion kommer att gå i en egen mapp, med roten är index.js för var och en. Detta är tydligt separerade allt, och gör det lättare att hantera
ProjectDirectory
|–mall.yml
|–Funktion
| |–index.js
|–AnotherFunction
|–index.js
CodePipeline stöder Github och BitBucket för källkontroll. Om du använder någon av dessa, allt du behöver göra är att skapa en ny branch för distributioner (eller helt enkelt använda master, om du är bra med det). Om du använder en annan tjänst du vill använda AWS egna CodeCommit source-kontroll som en sekundär arkivet, driver förändringar till det när du vill göra uppdateringar.
Att skriva en SAM-Mall
Detta steg kommer att vara den mest komplicerade, och den som är mest specifik för din funktion och dess krav. Du måste skapa en SAM mall som kommer att konfigurera din Lambda funktion, och alla dess resurser som krävs.
En grundläggande mall som ser ut ungefär så här:
AWSTemplateFormatVersion: ‘2010-09-09’
Förändra: AWS::Serverlösa-2016-10-31
Beskrivning: En AWS Serverlösa Specifikation mall som beskriver din funktion
Resurser:
HelloWorld:
Typ: AWS::Serverlösa::Funktion
Egenskaper:
Handler: HelloWorld/index.handler
Runtime: nodejs8.10
Detta register en resurs, ett Lambda-funktion, som körs på NodeJS, och har sin handler i HelloWorld/index.js.
Du kan använda andra resurser från SAM mall liksom. Till exempel, för att ge API Gateway tillstånd att åberopa din funktion och ställ in funktion för att köra på ett visst API väg, som du skulle lägga till följande:
AWSTemplateFormatVersion: ‘2010-09-09’
Förändra: AWS::Serverlösa-2016-10-31
Beskrivning: En AWS Serverlösa Specifikation mall som beskriver din funktion
Resurser:
HelloWorld:
Typ: AWS::Serverlösa::Funktion
Egenskaper:
Handler: HelloWorld/index.handler
Runtime: nodejs8.10
Händelser:
HelloWorldApi:
Typ: Api
Egenskaper:
Sökväg: /helloworld
Metod: FÅ
HelloWorldPermission:
Typ: AWS::Lambda::Tillstånd
Egenskaper:
Åtgärd: lambda:InvokeFunction
FunctionName:
Fn::GetAtt:
– HelloWorld
– Arn
Uppdragsgivare: apigateway.amazonaws.com
SourceArn:
Fn::Sub: arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:*/*/*/*
Du behöver definitivt mer specifika ändamål än vad som anges här, så för mer information om SAM kan du läsa vår guide att arbeta med det, AWS är guider för utvecklare, eller hela schemat på Github.
När du har en fungerande mall, du kan testa distribution genom att installera SAM-CLI:
pips installera aws-sam-cli
Sedan, du kommer paketet ditt projekt och förvara föremål i en S3 bucket:
sam paket
–template-fil mall.yml
–output-template-fil package.yml
–s3-hink hink-namn
Och du kommer att manuellt köra distribution:
sam distribuera
–template paketet.yml
–din stack namn sam-hello-world
–kapacitet CAPABILITY_IAM
Om allt har fungerat korrekt, bör du se en ny CloudFormation stack och en ansökan i Lambda med dina funktioner.
Förpackningar och Distribution Projektet med CodePipeline
Detta skede är inte frivilligt, även om du inte arbetar med ett kompilerat språk. Hjälp SAM mall, CodeBuild kommer här att användas för att hantera förpackningar projektet till något som kan användas med CodeDeploy mycket enkelt. Alternativt kan du köra andra kommandon innan förpackningar, som till exempel npm köra bygga och npm install (installera).
Först behöver du en utförande roll kan hantera den CloudFormation-uppdateringar. Öppna IAM Management Console för att lägga till en ny roll. Välj “CloudFormation” som den resurs som kommer att använda denna roll, då fäster “AWSLambdaExecute tillstånd politik.
Spara roll, öppna den och bifoga följande inline politik:
{
Förklaring: [
{
“Action”: [
“apigateway:*”,
“codedeploy:*”,
“lambda:*”,
“cloudformation:CreateChangeSet”,
“iam:GetRole”,
“iam:CreateRole”,
“iam:DeleteRole”,
“iam:PutRolePolicy”,
“iam:AttachRolePolicy”,
“iam:DeleteRolePolicy”,
“iam:DetachRolePolicy”,
“iam:PassRole”,
“s3:GetObject”,
“s3:GetObjectVersion”,
“s3:GetBucketVersioning”
],
“Resurs”: “*”,
“Effect”: “Tillåt”
}
],
“Version”: “2012-10-17”
}
Skapa en ny pipeline från CodePipeline konsolen. Välj den förvalda inställningar för att skapa en ny tjänst roll. Detta kommer att konfigureras automatiskt.
För källkontroll scenen, välja din källa kontroll typ, reporäntan, och släpper grenen.
För att bygga scenen, du vill skapa ett nytt projekt i CodeBuild. Standardkonfigurationen är bra, helt enkelt välja Amazon Linux 2 som bygger operativsystem, och välj standard runtime och standard bild.
Det viktigaste du behöver för codePipeline är din buildspec.yml filen placeras i roten på ditt projekt katalog. Detta ställer CodeBuild med de kommandon som den behöver för att köra. Följande konfiguration är ett exempel som installerar Maskin, alla NPM paket, går npm köra bygga och sedan paketerar allting upp för CloudFormation.
version: 0.2
faser:
installera:
runtime-versioner:
nodejs: 10
kommandon:
– npm install-g maskin
bygga:
kommandon:
– echo Bygga började på “date”
– npm install tid
– npm köra bygga
– export HINK=typescript-lambda
– aws cloudformation-paket –template-fil mall.yml –s3-hink $HINK –output-template-fil outputtemplate.yml
artefakter:
typ: zip
filer:
– mall.yml
– outputtemplate.yml
Du kommer förmodligen att behöva ändra detta så att det passar ditt projekt.
När det är gjort, kan du konfigurera den sista etappen. Snarare än att använda CodeDeploy men vi ska använda CloudFormation att uppdatera saker direkt, eftersom alla förpackningar som hände i att bygga etapp ändå. Välj “CloudFormation” som distribuerar leverantör, och åtgärd läge för att “Skapa eller ersätta en förändring.” Ange ett nytt namn, och förändring som namn.
För mallen, välj “BuildArtifact” och skriv in i outputtemplate.yml från föregående steg. Lägg till “Förmåga IAM” till de funktioner och välj den roll du manuellt skapade tidigare.
Klicka på “Skapa” och din pipeline bör köras utan fel. Dock CloudFormation skede gör en förändring, som är som en förhandsvisning av förändringar. Att faktiskt använda de förändringar som vi behöver för att genomföra den förändring som.
Klicka på “Redigera” på din skapade pipeline. Under “Distribuera,” klicka “Redigera” och klicka på “Lägg till Action Group” när det redan skapade åtgärder. Om du skapar nya åtgärder före detta, kommer det inte att fungera.
Välj “CloudFormation” som leverantör. Välj “BuildArtifact” som ingång artefakt. För action-läge och förändring som namn, in i samma värderingar som du har skapat för den första utbyggnaden åtgärder.
Klicka på “Spara” och du tas tillbaka till gasledningen skärm. Klicka på “Release Ändra” för att manuellt köra i gång igen. Det bör nu klar, och de förändringar som bör vara synliga i Lambda-konsolen.
Om du får fel, det är ganska lätt att spåra, så kan du klicka på “Mer Information” bredvid felmeddelande i CodePipeline. Det kan vara antingen en misslyckad bygga en ofullständig SAM mall, eller av otillräcklig behörighet för CodeBuild eller CloudFormation.
Om du begår förändringar för att din källa kontroll, bör upptäckas av CodePipeline, och börjar hela processen om igen.