Esempio di Amazon ECR per CodeBuild

Modalità Focus

Esempio di Amazon ECR per CodeBuild - AWS CodeBuild

Questo esempio utilizza un'immagine Docker in un repository di immagini Amazon Elastic Container Registry (Amazon ECR) per creare un progetto Go di esempio.

Importante

L'esecuzione di questo esempio potrebbe comportare addebiti sul tuo account. AWS Questi includono possibili addebiti per AWS CodeBuild e per AWS risorse e azioni relative ad Amazon S3 AWS KMS, CloudWatch Logs e Amazon ECR. Per ulteriori informazioni, consulta CodeBuild i prezzi, i prezzi di Amazon S3, i prezzi, i AWS Key Management Service prezzi di Amazon e CloudWatch i prezzi di Amazon Elastic Container Registry.

Argomenti

Esegui l'esempio di Amazon ECR

Esegui l'esempio di Amazon ECR

Utilizza le seguenti istruzioni per eseguire l'esempio di Amazon ECR per CodeBuild.

Per eseguire questo esempio

Per creare e inviare l'immagine Docker al tuo repository di immagini in Amazon ECR, completa i passaggi nella Esegui l'esempio «Pubblica immagine Docker su Amazon ECR' sezione del. Esempio «Pubblica immagine Docker su Amazon ECR'
Creazione di un progetto Go:
1. Crea i file come descritto nelle File di un progetto Go sezioni Struttura di un progetto Go e di questo argomento, quindi caricali in un bucket di input S3 o in un repository AWS CodeCommit, GitHub o Bitbucket.
  
  Importante
  Non caricare (root directory name), ma solo i file all'interno di (root directory name)
  Se si sta utilizzando un bucket di input S3, assicurarsi di creare un file ZIP contenente i file, quindi caricarlo nel bucket di input. Non aggiungere (root directory name) al file ZIP, ma solo i file all'interno di (root directory name)
2. Crea un progetto di compilazione, esegui la build e visualizza le relative informazioni sulla build.
  
  Se usi il AWS CLI per creare il progetto di compilazione, l'input in formato JSON del create-project comando potrebbe avere un aspetto simile a questo. (Sostituire i segnaposto con i propri valori).
```
{
  "name": "sample-go-project",
  "source": {
    "type": "S3",
    "location": "codebuild-region-ID-account-ID-input-bucket/GoSample.zip"
  },
  "artifacts": {
    "type": "S3",
    "location": "codebuild-region-ID-account-ID-output-bucket",
    "packaging": "ZIP",
    "name": "GoOutputArtifact.zip"
  },
  "environment": {
    "type": "LINUX_CONTAINER",
    "image": "aws/codebuild/standard:5.0",
    "computeType": "BUILD_GENERAL1_SMALL"
  },
  "serviceRole": "arn:aws:iam::account-ID:role/role-name",
  "encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
3. Per ottenere l'artefatto di output della compilazione, aprire il bucket di output S3.
4. Scaricare il file GoOutputArtifact.zip sul computer locale o sull'istanza, quindi estrarre il contenuto del file. Tra i contenuti estratti, selezionare il file hello.
Se una delle seguenti condizioni è vera, devi aggiungere le autorizzazioni al tuo repository di immagini in Amazon ECR in modo che AWS CodeBuild possa inserire la sua immagine Docker nell'ambiente di compilazione.
- Il tuo progetto utilizza CodeBuild le credenziali per estrarre immagini Amazon ECR. Questo è indicato dal valore CODEBUILD nell'attributo imagePullCredentialsType di ProjectEnvironment.
- Il tuo progetto utilizza un'immagine Amazon ECR per più account. In questo caso, il progetto deve utilizzare il suo ruolo di servizio per estrarre immagini Amazon ECR. Per abilitare questo comportamento, impostare l'attributo imagePullCredentialsType di ProjectEnvironment su SERVICE_ROLE.
1. Apri la console Amazon ECR all'indirizzo https://console.aws.amazon.com/ecr/.
2. Nella lista dei nomi dei repository, selezionare il nome del repository creato o selezionato.
3. Dal riquadro di navigazione scegliere Permissions (Autorizzazioni), Edit (Modifica), quindi scegliere Add statement (Aggiungi istruzione).
4. In Nome istruzione, immettere un identificatore (ad esempio, CodeBuildAccess).
5. Per Effect (Effetto), lasciare selezionato Allow (Abilita). Questo indica che vuoi consentire l'accesso a un altro account AWS .
6. Per Principal (Principale), eseguire una delle seguenti operazioni:
  - Se il tuo progetto utilizza CodeBuild le credenziali per estrarre un'immagine Amazon ECR, in Service principal, inserisci. codebuild.amazonaws.com
  - Se il tuo progetto utilizza un'immagine Amazon ECR per più account, per AWS account IDs inserisci IDs gli AWS account a cui desideri consentire l'accesso.
7. Saltare la lista All IAM entities (Tutte le entità IAM).
8. Per Azione, seleziona le azioni di sola estrazione: ecr:GetDownloadUrlForLayer, ecr: ed ecr:. BatchGetImage BatchCheckLayerAvailability
9. Per Condizioni, aggiungi quanto segue:
```
{
   "StringEquals":{
      "aws:SourceAccount":"<AWS-account-ID>",
      "aws:SourceArn":"arn:aws:codebuild:<region>:<AWS-account-ID>:project/<project-name>"
   }
}
```
10. Seleziona Salva.
  
  Questa policy viene visualizzata in Autorizzazioni. L'entità principal è ciò che è stato immesso per Principal (Entità principal) al passaggio 3 di questa procedura:
  - Se il tuo progetto utilizza CodeBuild credenziali per estrarre un'immagine Amazon ECR, "codebuild.amazonaws.com" viene visualizzato in Service principals.
  - Se il tuo progetto utilizza un'immagine Amazon ECR per più account, l'ID dell' AWS account a cui desideri consentire l'accesso viene visualizzato in AWS Account. IDs
    
    La seguente policy di esempio utilizza sia CodeBuild le credenziali che un'immagine Amazon ECR per più account.
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Sid":"CodeBuildAccessPrincipal",
         "Effect":"Allow",
         "Principal":{
            "Service":"codebuild.amazonaws.com"
         },
         "Action":[
            "ecr:GetDownloadUrlForLayer",
            "ecr:BatchGetImage",
            "ecr:BatchCheckLayerAvailability"
         ],
         "Condition":{
            "StringEquals":{
               "aws:SourceArn":"arn:aws:codebuild:<region>:<aws-account-id>:project/<project-name>",
               "aws:SourceAccount":"<aws-account-id>"
            }
         }
      },
      {
         "Sid":"CodeBuildAccessCrossAccount",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam::<AWS-account-ID>:root"
         },
         "Action":[
            "ecr:GetDownloadUrlForLayer",
            "ecr:BatchGetImage",
            "ecr:BatchCheckLayerAvailability"
         ]
      }
   ]
}
```
  - Se i tuoi progetti utilizzano CodeBuild credenziali e desideri che abbiano accesso aperto all'archivio Amazon ECR, puoi omettere Condition le chiavi e aggiungere la seguente politica di esempio. CodeBuild
```
{
  "Version":"2012-10-17",
  "Statement":[
    {
      "Sid":"CodeBuildAccessPrincipal",
      "Effect":"Allow",
      "Principal":{
        "Service":"codebuild.amazonaws.com"
      },
      "Action":[
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage",
        "ecr:BatchCheckLayerAvailability"
      ]
    },
    {
      "Sid":"CodeBuildAccessCrossAccount",
      "Effect":"Allow",
      "Principal":{
        "AWS":"arn:aws:iam::<AWS-account-ID>:root"
      },
      "Action":[
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage",
        "ecr:BatchCheckLayerAvailability"
      ]
    }
  ]
}
```

Crea un progetto di compilazione, esegui la build e visualizza le informazioni sulla build.

Se usi il AWS CLI per creare il progetto di compilazione, l'input in formato JSON del create-project comando potrebbe avere un aspetto simile a questo. (Sostituire i segnaposto con i propri valori).


{
  "name": "amazon-ecr-sample-project",
  "source": {
    "type": "S3",
    "location": "codebuild-region-ID-account-ID-input-bucket/GoSample.zip"
  },
  "artifacts": {
    "type": "S3",
    "location": "codebuild-region-ID-account-ID-output-bucket",
    "packaging": "ZIP",
    "name": "GoOutputArtifact.zip"
  },
  "environment": {
    "type": "LINUX_CONTAINER",
    "image": "account-ID.dkr.ecr.region-ID.amazonaws.com/your-Amazon-ECR-repo-name:tag",
    "computeType": "BUILD_GENERAL1_SMALL"
  },
  "serviceRole": "arn:aws:iam::account-ID:role/role-name",
  "encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}

Per ottenere l'artefatto di output della compilazione, aprire il bucket di output S3.
Scaricare il file GoOutputArtifact.zip sul computer locale o sull'istanza, quindi estratte il contenuto del file GoOutputArtifact.zip. Tra i contenuti estratti, selezionare il file hello.

Struttura di un progetto Go

Questo esempio assume la seguente struttura delle directory.


(root directory name)
├── buildspec.yml
└── hello.go

File di un progetto Go

Questo esempio utilizza i seguenti file.

buildspec.yml (in (root directory name))


version: 0.2

phases:
  install: 
   runtime-versions: 
     golang: 1.13 
  build:
    commands:
      - echo Build started on `date`
      - echo Compiling the Go code
      - go build hello.go 
  post_build:
    commands:
      - echo Build completed on `date`
artifacts:
  files:
    - hello

hello.go (in (root directory name))


package main
import "fmt"

func main() {
  fmt.Println("hello world")
  fmt.Println("1+1 =", 1+1)
  fmt.Println("7.0/3.0 =", 7.0/3.0)
  fmt.Println(true && false)
  fmt.Println(true || false)
  fmt.Println(!true)
}