Lambda è un web-based editor di testo che probabilmente hai usato prima per la scrittura di funzioni. È grande per i principianti imparare la piattaforma, ma non è il modo migliore per andare circa la gestione degli aggiornamenti. Ecco come seguire le sue funzioni Lambda su Git.
Come CI/CD Per Lambda Funziona
Invece di usare il manuale editor, è necessario sviluppare le funzioni localmente, commit e spingere le modifiche a un repo Git, e hanno CodePipeline gestire la costruzione e la distribuzione per voi.
CodePipeline viene eseguito automaticamente ogni volta che rileva i cambiamenti nel controllo del codice sorgente, e invia le modifiche a CodeBuild (o Jenkins) per la costruzione. Questo passaggio è facoltativo, e si potrebbe non utilizzare per la Lambda, ma se stai usando qualcosa come Dattiloscritto avrete bisogno di questa fase. Dopo la costruzione, le modifiche vengono trasmessi CodeDeploy, che gestisce la distribuzione.
CodeDeploy si aggiornerà automaticamente le funzioni Lambda e spingere una nuova versione. Per rendere il processo di distribuzione più uniforme, è possibile spostare il traffico graduale, utilizzando un alias, fino al 100% del traffico è diretto verso la nuova funzione.
Per gestire la distribuzione effettiva, CodeDeploy utilizza AWS è Serverless Modello di Domanda (SAM). SAM è un’estensione di CloudFormation, un’infrastruttura come servizio codice. Si tratta fondamentalmente di un leggibile dati-linguaggio di serializzazione (YAML) modello che viene utilizzato per gestire la configurazione associati con la distribuzione di funzioni Lambda e i loro prerequisiti, ed è una parte vitale di essere in grado di distribuire utilizzando solo il codice.
Impostazione Di Controllo Di Origine
Questo passo è abbastanza semplice. Puoi creare un nuovo progetto di directory per contenere tutto il codice, e la inizializza con Git. SAM modello di andare alla radice di questa directory, nome modello.yml. Ogni funzione di andare nella propria cartella, con la radice è index.js per ciascuno di essi. Questo separa chiaramente tutto, e rende più facile da gestire
ProjectDirectory
|–modello.yml
|–Function
| |–index.js
|–AnotherFunction
|–index.js
CodePipeline supporta Github e BitBucket per il controllo del codice sorgente. Se si sta utilizzando uno di questi, tutto quello che dovrete fare è creare un nuovo ramo per le distribuzioni (o semplicemente utilizzare i master, se ti va bene). Se si utilizza un servizio diverso, che si desidera utilizzare AWS proprio CodeCommit controllo del codice sorgente secondaria repository, spingendo le modifiche ad esso ogni volta che vuoi fare gli aggiornamenti.
La scrittura di un Modello SAM
Di questo passo sarà più complicato, e più specifico per la funzione e le sue esigenze. Dovrete creare un SAM modello di configurare la funzione Lambda, e tutte le sue risorse necessarie.
Un modello di base è qualcosa di simile a questo:
AWSTemplateFormatVersion: ‘2010-09-09’
Trasformazione: AWS::Serverless-2016-10-31
Descrizione: AWS Serverless Specifica del modello che descrive la funzione
Risorse:
HelloWorld:
Tipo: AWS::Serverless::Funzione
Proprietà:
Gestore: HelloWorld/indice.gestore
Runtime: nodejs8.10
Questo registra una risorsa, una funzione Lambda, che gira su NodeJS, e ha il suo gestore HelloWorld/index.js.
È possibile distribuire le altre risorse SAM modello. Per esempio, per dare il Gateway API di autorizzazione per richiamare la funzione e impostare la funzione per eseguire su una specifica API percorso, è aggiunta la seguente:
AWSTemplateFormatVersion: ‘2010-09-09’
Trasformazione: AWS::Serverless-2016-10-31
Descrizione: AWS Serverless Specifica del modello che descrive la funzione
Risorse:
HelloWorld:
Tipo: AWS::Serverless::Funzione
Proprietà:
Gestore: HelloWorld/indice.gestore
Runtime: nodejs8.10
Eventi:
HelloWorldApi:
Tipo: Api
Proprietà:
Percorso: /helloworld
Metodo: OTTENERE
HelloWorldPermission:
Tipo: AWS::Lambda::Autorizzazione
Proprietà:
Azione: lambda:InvokeFunction
Nomefunzione:
Fn::GetAtt:
– HelloWorld
– Arn
Principali: apigateway.amazonaws.com
SourceArn:
Fn::Sub: arn:aws:execute-api:${AWS::Regione}:${AWS::AccountId}:*/*/*/*
Sicuramente avrete bisogno di più usi specifici di quelli che possono essere elencati qui, quindi per ulteriori informazioni su SAM potete leggere la nostra guida per lavorare con esso, AWS developer guide, o lo schema completo su Github.
Una volta che si dispone di un lavoro di modello, è possibile verificare la distribuzione installando il SAM CLI:
pip install aws-sam-cli
Poi, sarà il pacchetto di progetto e memorizzare gli elementi di un S3 secchio:
sam pacchetto
–modello-modello di file.yml
–output-modello-pacchetto di file.yml
–s3-secchio secchio nome
E si esegue manualmente la distribuzione:
sam distribuire
–modello-pacchetto di file.yml
–stack-nome sam-ciao-mondo
–capacità CAPABILITY_IAM
Se tutto ha funzionato correttamente, si dovrebbe vedere un nuovo CloudFormation stack e un’applicazione in Lambda con le vostre funzioni.
Il confezionamento e la Distribuzione del Progetto con CodePipeline
Questa fase non è un optional, anche se non stai lavorando con un linguaggio compilato. Utilizzando il modello SAM, CodeBuild verrà utilizzato per gestire il confezionamento il progetto in qualcosa che può essere distribuito con CodeDeploy molto facilmente. Facoltativamente, è possibile eseguire altri comandi prima di imballaggio, come npm eseguire costruire e npm install.
In primo luogo, avrete bisogno di una esecuzione di ruolo in grado di gestire il CloudFormation aggiornamenti. Aprire la IAM Management Console per aggiungere un nuovo ruolo. Selezionare “CloudFormation” come risorsa di utilizzare questo ruolo, quindi collegare il “AWSLambdaExecute criteri di autorizzazione.
Salvare il ruolo di, aprirlo, e allegare i seguenti inline politica:
{
“Dichiarazione”: [
{
“Azione”: [
“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”
],
“Risorsa”: “*”,
“Effetto”: “Permettere”
}
],
“Versione”: “2012-10-17”
}
Creare un nuovo gasdotto che dal CodePipeline console. Scegliere le impostazioni predefinite di creazione di un nuovo servizio di ruolo. Questo verrà configurato automaticamente.
Per il controllo del codice sorgente fase, scegli il tipo di controllo, repo, e ramo di rilascio.
Per la fase di creazione, è necessario creare un nuovo progetto in CodeBuild. La configurazione di default va bene, basta scegliere Amazon Linux 2 come build del sistema operativo, e selezionare il runtime standard e standard di immagine.
La cosa principale è necessario per codePipeline è il tuo buildspec.file yml, posizionato nella root della directory del progetto. In questo modo si configura CodeBuild con i comandi necessari per l’esecuzione. La seguente configurazione è un esempio che installa Dattiloscritto, tutti NPM pacchetti, esegue npm eseguire la generazione, e poi pacchetti tutto per CloudFormation.
versione: 0.2
fasi:
installare:
runtime-versioni:
nodejs: 10
comandi:
– npm install-g dattiloscritto
costruire:
comandi:
– eco Costruire iniziato nel `data`
– npm install tempo
– npm eseguire build
– esportazione SECCHIO=dattiloscritto-lambda
– aws cloudformation pacchetto –modello-modello di file.yml –s3-secchio $SECCHIO –output-modello-file outputtemplate.yml
artefatti:
tipo: zip
file:
– modello.yml
– outputtemplate.yml
Probabilmente devi modificare questo per soddisfare il vostro progetto.
Una volta fatto, è possibile configurare la fase finale. Piuttosto che usare CodeDeploy, però, faremo uso CloudFormation per aggiornare le cose direttamente, come tutti del packaging è accaduto in fase di costruzione in ogni caso. Scegliere “CloudFormation” come distribuire provider, e impostare la modalità di azione di “Creare o sostituire una serie di modifiche.” Immettere un nuovo nome, e cambiare il nome del set.
Per il modello, selezionare “BuildArtifact,” ed entrare nel outputtemplate.yml dal passaggio precedente. Aggiungere Funzionalità di IAM” per la capacità e selezionare il servizio di ruolo manualmente creato in precedenza.
Fare clic su “Crea” e la tua pipeline deve essere eseguito senza errori. Tuttavia, il CloudFormation fase fa una serie di modifiche, che è come un’anteprima delle modifiche. Effettivamente distribuire le modifiche, abbiamo bisogno di eseguire il cambio set.
Fare clic su “Modifica” sul tuo creato pipeline. Al di sotto di “Distribuire”, fare clic su “Modifica” e fare clic su “Aggiungi Gruppo di Azione” dopo aver già creato più di azione. Se si crea la nuova azione prima di questo, non funziona.
Scegliere “CloudFormation” come provider. Selezionare “BuildArtifact” come input artefatto. Per le modalità di azione e di cambiare nome, immettere negli stessi valori, creato per la prima azione di distribuzione.
Fare clic su “Salva” e sarai portato indietro la pipeline schermata principale. Fare clic su “Rilasciare il Cambiamento” per eseguire manualmente la pipeline di nuovo. Si dovrebbe completare, e le modifiche devono essere visibili in Lambda console.
Se si riscontrano errori, è abbastanza facile da rintracciare, come è possibile fare clic su “Ulteriori Dettagli” accanto al messaggio di errore in CodePipeline. E ‘ probabile che sia un fallito, un incompleto SAM modello, o di autorizzazioni insufficienti per CodeBuild o CloudFormation.
Se si eseguire il commit delle modifiche del controllo del codice sorgente, dovrebbe essere rilevata da CodePipeline, e avviare l’intero processo di nuovo.