Automatizzare la Consegna Continua in Contenitori con CodeBuild, ECR, e CodeDeploy

0
34
Shutterstock/Ribkhan

L’Integrazione continua/Continua di Consegna (CI/CD) è il processo di automatizzazione aggiornamenti dell’applicazione, da cambiamenti nel controllo del codice sorgente, per le generazioni automatiche, per le distribuzioni automatiche per il vostro server. AWS offre un servizio per questo, chiamato CodePipeline, che può essere configurato per funzionare con i contenitori.

Continua la Consegna in Container

I contenitori sono un po ‘ più complicato rispetto alle tradizionali applicazioni. Molti containerizzato applicazioni effettivamente fare uso di due immagini di contenitore. La prima, chiamata l’immagine di base, è essenzialmente un custom AMI precaricato con le dipendenze e di altre applicazioni. Questo viene fatto per accelerare i tempi di costruzione, perché se sei solo di aggiornare l’applicazione del codice, non è necessario andare reinstallazione di NGINX e ogni altro po ‘ di software sul contenitore. La seconda immagine è la vera immagine dell’applicazione, che estende l’immagine di base e contiene il tuo codice.

Come tale, CI/CD pipeline che si creerà sarà effettivamente due oleodotti. La prima si guarda per cambiamenti nell’immagine di base e innescare una ricostruzione di un aggiornamento in RACC quando succede. Il secondo gasdotto conterrà due di origine fasi—una che guarda per cambiamenti nell’immagine di base dell’ECR repository, e uno che ascolta per gli aggiornamenti in l’immagine dell’applicazione del codice sorgente. In questo modo, se siete solo di aggiornare l’applicazione dell’immagine, l’immagine di base non ha bisogno di ricostruzione.

Con due condotte, CodePipeline attiverà gli aggiornamenti delle applicazioni in uno dei due modi:

  • Modifiche all’immagine dell’applicazione attiverà una ricostruzione dell’immagine dell’applicazione, utilizzando la più recente immagine di base, che non ha bisogno di essere ricostruito. L’aggiornamento sarà spinto a ECR, con l’opzione di distribuzione a ECS o un altro contenitore di servizio.
  • Modifiche all’immagine di base attiverà una ricostruzione dell’immagine di base, che permetterà di distribuire gli aggiornamenti per RACC. Questo, a sua volta, innescare una ricostruzione dell’immagine dell’applicazione, che sarà spinto a ECR e poi a ECS.

Tuttavia, questa doppia pipeline di installazione potrebbe non essere necessario per tutte le applicazioni, e se si utilizza una precompilati base immagine del sistema operativo come Ubuntu, avrete solo bisogno di una pipeline di gestire il tutto.

IAM Ruolo di Installazione

Per prima cosa, dovrete impostare un ruolo di servizio per dare CodeBuild le autorizzazioni necessarie per interagire con altri servizi AWS (come ECR) sul vostro conto. Aprire la IAM Management Console, quindi creare un nuovo ruolo in “Ruoli”. Scegliere “AWS Servizio” e selezionare CodeBuild nell’elenco.

Per le politiche, si desidera creare una nuova politica con le seguenti autorizzazioni:

{
“Versione”: “2012-10-17”,
“Dichiarazione”: [
{
“Sid”: “CloudWatchLogsPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“registri:CreateLogGroup”,
“registri:CreateLogStream”,
“registri:PutLogEvents”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “CodeCommitPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“codecommit:GitPull”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “S3GetObjectPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“s3:GetObject”,
“s3:GetObjectVersion”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “S3PutObjectPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“s3:PutObject”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “ECRPullPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“ecr:BatchCheckLayerAvailability”,
“ecr:GetDownloadUrlForLayer”,
“ecr:BatchGetImage”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “ECRAuthPolicy”,
“Effetto”: “Consenti”,
“Azione”: [
“ecr:GetAuthorizationToken”
],
“Risorsa”: [
“*”
]
},
{
“Sid”: “S3BucketIdentity”,
“Effetto”: “Consenti”,
“Azione”: [
“s3:GetBucketAcl”,
“s3:GetBucketLocation”
],
“Risorsa”:
“*”
}
]
}

Incolla questo in meno di JSON scheda nell’editor della politica. Dare un nome, e di allegarlo al ruolo. Potrai anche desidera collegare il premade politica, AmazonEC2ContainerRegistryPowerUser.

Una volta che questi due criteri sono indicati il ruolo di un nome e fare clic su crea.

La configurazione di Controllo del codice Sorgente e CodeBuild

CodePipeline supporta tirando aggiornamenti del codice da GitHub, BitBucket, e AWS proprio CodeCommit controllo del codice sorgente. Avrete la migliore esperienza possibile utilizzando CodeCommit come secondario, rilascio repository, ma GitHub funziona bene. Se si utilizza GitLab o un altro provider, è necessario utilizzare CodeCommit per spingere gli aggiornamenti.

Per questo passaggio, è necessario disporre di due diversi repository, uno per l’immagine di base e uno per l’immagine dell’applicazione. Se non si utilizza una base dell’immagine, è possibile saltare la configurazione per farlo.

Per l’immagine di base, è necessario creare un buildspec file, essenzialmente una lista di comandi che CodeBuild verrà eseguito durante la costruzione della propria immagine. Si può entrare in questo manualmente quando l’impostazione di CodeBuild, ma è meglio salvarlo come un file chiamato buildspec.yml nella root del vostro repository.

La tua configurazione esatta può variare a seconda dei requisiti dell’applicazione, ma dovrebbe essere qualcosa come questo:

versione: 0.2

fasi:
pre_build:
comandi:
– eco-log in, Amazon RACC…
– aws –version
– $(aws ecr get-login –regione $AWS_DEFAULT_REGION –no-sono-e-mail)
– REPOSITORY_URI=012345678910.dkr.ecr.us-east-1.amazonaws.com/base-image
– COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut-c 1-7)
– IMAGE_TAG=${COMMIT_HASH:=ultimi}
costruire:
comandi:
– eco Costruire iniziato nel `data`
– eco, Costruire il Mobile immagine…
– mobile build-t $REPOSITORY_URI:più recenti .
– mobile tag $REPOSITORY_URI:ultima $REPOSITORY_URI:$IMAGE_TAG
post_build:
comandi:
– eco Costruire completato in `data`
– eco Spingendo la finestra Mobile di immagini…
– mobile push $REPOSITORY_URI:le ultime
– mobile push $REPOSITORY_URI:$IMAGE_TAG

Questo esempio di log in RACC, impostare il tag di immagine per la CodeBuild ID creazione, costruire il Mobile immagine, quindi inserire le modifiche al tuo ECR repository. Si può decidere di cambiare il REPOSITORY_URI dichiarazione di variabile per essere l’URI del vostro target di RACCOLTA repository.

Salvare questo come buildspec.yml, e metterlo nella root sia la vostra base repository di immagini e l’immagine dell’applicazione del repository. È possibile testare le vostre buildspec avviando manualmente una build da CodeBuild console, o semplicemente procedere con la pipeline di installazione e correggere eventuali errori che possono sorgere.

Impostazione della Pipeline

Una volta che hai la tua buildspec in ordine, aprire il CodePipeline Console, e creare un nuovo gasdotto per l’immagine di base. Dare un nome, e permette di creare un nuovo servizio di ruolo. Per l’origine la fase di controllo, scegliere il tipo che si sta utilizzando, e selezionare un repository e ramo. Se si desidera, è possibile impostare un ulteriore ramo per tenere traccia di versioni, e CodePipeline ignora modifiche al master.

Per la fase di creazione, selezionare “Crea Progetto”. Questo farà apparire una finestra di dialogo in cui è possibile configurare CodeBuild.

Normalmente, devi collegare CodeBuild per il controllo del codice sorgente, ma che viene gestita automaticamente dalla pipeline durante la creazione di un nuovo progetto in questo modo. Dovrete configurare l’ambiente di compilazione viene eseguito in, è possibile scegliere una custom Mobile immagine, caricata con tutti i programmi necessari per la costruzione di, oppure è possibile installare manualmente nel prebuild fase di buildspec.yml. Se non hai bisogno di nulla di speciale, è possibile selezionare Amazon Linux 2 e il runtime di default, che viene fornito con la maggior parte dei linguaggio di programmazione runtime così come finestra Mobile preinstallato.

Inoltre ti consigliamo di selezionare il servizio di ruolo creato in precedenza:

Infine, è possibile modificare manualmente il nome del buildspec file, se non vuoi farlo nella directory principale della sorgente o più file, è necessario distinguere tra. È anche possibile inserire comandi di compilazione manualmente, ma si consiglia di monitoraggio come un file su git.

Per la distribuzione di fase, avrai voglia di saltare per l’immagine di base. Il buildspec file di costruire e spingere modifiche ECR, che è tutto il necessario per questo passaggio. È possibile verificare la pipeline spingendo modifiche alla vostra immagine di base repository.

Impostazione dell’Immagine dell’Applicazione della Pipeline

Successivamente, sarà istituito un altro cantiere per l’applicazione dell’immagine. Creare un nuovo gasdotto che dalla console, e selezionare “ECR” come sorgente. Selezionare l’immagine di base repository, e lasciare il tag di immagine vuota, che di default è al più recente.

Per la fase di creazione, è necessario configurare il CodeBuild in modo molto simile a come l’immagine di base stage—creare un nuovo progetto di costruzione, selezionare l’ambiente di default, e immettere in servizio di ruolo creato in precedenza.

La fase di distribuzione è facoltativo. Senza di essa, le modifiche alla base dell’immagine o l’immagine dell’applicazione, sarà sufficiente attivare l’applicazione di immagine per la ricostruzione e il push delle modifiche per RACC. Tuttavia, se si sta utilizzando ECS per la distribuzione, è possibile aggiungere un’altra tappa che porterà la vostra immagine e aggiornare i server.

In ogni modo, fare clic su crea per creare la pipeline. Alcune modifiche sono necessarie prima che possa funzionare, però, quindi fare clic su “Modifica” nella pipeline, poi su “Modifica Stage” per il controllo del codice sorgente fase:

Così com’è, la fonte delle fasi di controllo, semplicemente tira da ECR per l’immagine di base. Questo è necessario, ma occorre anche il codice dell’applicazione per fare qualcosa di utile e anche rispondere ai cambiamenti nel codice dell’applicazione (non solo l’immagine di base).

Fare Clic Su “Aggiungi Azione:”

Scegli CodeCommit (o altra fonte di controllo) come il tipo di azione, e selezionare il repository e ramo. Per “Uscita ” Artefatti” da inserire in SourceArtifact per indicare che questo è il codice sorgente dell’applicazione.

Potrai anche desidera modificare l’ECR fase di specificare che l’uscita artefatto è un Immagine di Base.

Questo dovrebbe essere tutto ciò che CodeBuild deve eseguire, e una volta che si aggiorna il gasdotto che dovrebbe funzionare di nuovo, si spera, senza errori.

Se vi imbattete in errori, è probabile che il buildspec per CodeBuild non funziona correttamente. È possibile visualizzare i log di costruzione dal CodeBuild console, o consultare AWS Build Specifiche di Riferimento per ulteriori informazioni su come funziona il tutto.