Esegui un contenitore Docker - AWS IoT Greengrass
RequisitiEsegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker HubEsegui un contenitore Docker da un'immagine privata in Amazon ECREsegui un contenitore Docker da un'immagine in Amazon S3Usa la comunicazione tra processi nei componenti del contenitore DockerUsa AWS le credenziali nei componenti del contenitore Docker (Linux)Usa lo stream manager nei componenti del contenitore Docker (Linux)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Esegui un contenitore Docker

Puoi configurare AWS IoT Greengrass i componenti per eseguire un contenitore Docker da immagini archiviate nelle seguenti posizioni:

  • Archivi di immagini pubblici e privati in Amazon Elastic Container Registry (Amazon ECR)

  • Archivio pubblico di Docker Hub

  • Registro pubblico affidabile di Docker

  • Bucket S3

Nel componente personalizzato, includi l'URI dell'immagine Docker come artefatto per recuperare l'immagine ed eseguirla sul dispositivo principale. Per le immagini di Amazon ECR e Docker Hub, puoi utilizzare il componente Docker Application Manager per scaricare le immagini e gestire le credenziali per i repository Amazon ECR privati.

Requisiti

Per eseguire un contenitore Docker in un componente, è necessario quanto segue:

  • Un dispositivo principale Greengrass. Se non lo hai, consultare Tutorial: Nozioni di base su AWS IoT Greengrass V2.

  • Docker Engine 1.9.1 o versione successiva installato sul dispositivo principale Greengrass. La versione 20.10 è l'ultima versione verificata per funzionare con il software Core. AWS IoT Greengrass È necessario installare Docker direttamente sul dispositivo principale prima di distribuire componenti che eseguono contenitori Docker.

    Suggerimento

    Puoi anche configurare il dispositivo principale per installare Docker Engine quando il componente viene installato. Ad esempio, lo script di installazione seguente installa Docker Engine prima di caricare l'immagine Docker. Questo script di installazione funziona su distribuzioni Linux basate su Debian, come Ubuntu. Se si configura il componente per installare Docker Engine con questo comando, potrebbe essere necessario impostarlo true nello script del ciclo di vita RequiresPrivilege per eseguire l'installazione e i comandi. docker Per ulteriori informazioni, consulta AWS IoT Greengrassriferimento alla ricetta del componente.

    apt-get install docker-ce docker-ce-cli containerd.io && docker load -i {artifacts:path}/hello-world.tar

  • L'utente di sistema che esegue un componente del contenitore Docker deve disporre delle autorizzazioni di root o amministratore oppure è necessario configurare Docker per eseguirlo come utente non root o non amministratore.

    • Sui dispositivi Linux, puoi aggiungere un utente al gruppo senza il quale chiamare i comandi. docker docker sudo

    • Nei dispositivi Windows, è possibile aggiungere un utente al docker-users gruppo per richiamare docker comandi senza privilegi di amministratore.

    Linux or Unix

    Per aggiungere ggc_user al docker gruppo l'utente non root che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente.

    sudo usermod -aG docker ggc_user

    Per ulteriori informazioni, consulta Gestire Docker come utente non root.

    Windows Command Prompt (CMD)

    Per aggiungere al docker-users gruppoggc_user, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.

    net localgroup docker-users ggc_user /add
    Windows PowerShell

    Per aggiungere al docker-users gruppoggc_user, o l'utente che usi per eseguire i componenti del contenitore Docker, esegui il comando seguente come amministratore.

    Add-LocalGroupMember -Group docker-users -Member ggc_user

  • File a cui accede il componente del contenitore Docker montato come volume nel contenitore Docker.

  • Se configuri il software AWS IoT Greengrass Core per utilizzare un proxy di rete, devi configurare Docker per utilizzare lo stesso server proxy.

Oltre a questi requisiti, è necessario soddisfare anche i seguenti requisiti, se applicabili al proprio ambiente:

  • Per utilizzare Docker Compose per creare e avviare i tuoi contenitori Docker, installa Docker Compose sul tuo dispositivo principale Greengrass e carica il file Docker Compose in un bucket S3. È necessario archiviare il file Compose in un bucket S3 nello stesso ambiente del componente. Account AWS Regione AWS Per un esempio che utilizza il docker-compose up comando in un componente personalizzato, vedi. Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub

  • Se utilizzi un AWS IoT Greengrass proxy di rete, configura il demone Docker per utilizzare un server proxy.

  • Se le tue immagini Docker sono archiviate in Amazon ECR o Docker Hub, includi il componente Docker component manager come dipendenza nel tuo componente contenitore Docker. È necessario avviare il demone Docker sul dispositivo principale prima di distribuire il componente.

    Inoltre, includi gli URI dell'immagine come artefatti dei componenti. Gli URI delle immagini devono essere nel formato illustrato negli docker:registry/image[:tag|@digest] esempi seguenti:

    • Immagine Amazon ECR privata: docker:account-id.dkr.ecr.region.amazonaws.com/repository/image[:tag|@digest]

    • Immagine pubblica di Amazon ECR: docker:public.ecr.aws/repository/image[:tag|@digest]

    • Immagine pubblica di Docker Hub: docker:name[:tag|@digest]

    Per ulteriori informazioni sull'esecuzione di contenitori Docker da immagini archiviate in archivi pubblici, consulta. Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub

  • Se le tue immagini Docker sono archiviate in un repository privato Amazon ECR, devi includere il componente del servizio di scambio di token come dipendenza nel componente contenitore Docker. Inoltre, il ruolo del dispositivo Greengrass deve consentire le ecr:GetDownloadUrlForLayer azioniecr:GetAuthorizationToken, eecr:BatchGetImage, come mostrato nell'esempio seguente di politica IAM. 

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchGetImage",
        "ecr:GetDownloadUrlForLayer"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in un repository privato Amazon ECR, consulta. Esegui un contenitore Docker da un'immagine privata in Amazon ECR

  • Per utilizzare le immagini Docker archiviate in un repository privato Amazon ECR, l'archivio privato deve trovarsi nello Regione AWS stesso dispositivo principale.

  • Se le immagini Docker o i file Compose sono archiviati in un bucket S3, il ruolo del dispositivo Greengrass deve consentire l's3:GetObjectautorizzazione per consentire ai dispositivi principali di scaricare le immagini come artefatti componenti, come mostrato nel seguente esempio di politica IAM. 

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "s3:GetObject"
      ],
      "Resource": [
        "*"
      ],
      "Effect": "Allow"
    }
  ]
}

    Per informazioni sull'esecuzione di contenitori Docker da immagini archiviate in Amazon S3, consulta. Esegui un contenitore Docker da un'immagine in Amazon S3

  • Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:

Esegui un contenitore Docker da un'immagine pubblica in Amazon ECR o Docker Hub

Questa sezione descrive come creare un componente personalizzato che utilizza Docker Compose per eseguire un contenitore Docker da immagini Docker archiviate in Amazon ECR e Docker Hub.

Per eseguire un contenitore Docker utilizzando Docker Compose

  1. Crea e carica un file Docker Compose in un bucket Amazon S3. Assicurati che il ruolo del dispositivo Greengrass consenta l's3:GetObjectautorizzazione per consentire al dispositivo di accedere al file Compose. Il file Compose di esempio mostrato nell'esempio seguente include l'immagine Amazon CloudWatch Agent di Amazon ECR e l'immagine MySQL di Docker Hub.

    version: "3"
services:
  cloudwatchagent:
    image: "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
  mysql:
    image: "mysql:8.0"

  2. Crea un componente personalizzato sul tuo dispositivo principale. AWS IoT Greengrass La ricetta di esempio mostrata nell'esempio seguente ha le seguenti proprietà:

    • Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass scaricare immagini dai repository pubblici di Amazon ECR e Docker Hub.

    • Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR pubblico.

    • Un elemento componente che specifica un'immagine Docker in un repository pubblico di Docker Hub.

    • Un elemento componente che specifica il file Docker Compose che include i contenitori per le immagini Docker che si desidera eseguire.

    • Uno script di esecuzione del ciclo di vita che utilizza docker-compose up per creare e avviare un contenitore dalle immagini specificate.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyDockerComposeComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker-compose -f {artifacts:path}/docker-compose.yaml up"
      },
      "Artifacts": [
        {
          "URI": "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
        },
        {
          "URI": "docker:mysql:8.0"
        },
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyDockerComposeComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that uses Docker Compose to run images from public Amazon ECR and Docker Hub.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker-compose -f {artifacts:path}/docker-compose.yaml up
    Artifacts:
      - URI: "docker:public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest"
      - URI: "docker:mysql:8.0"
      - URI: "s3://DOC-EXAMPLE-BUCKET/folder/docker-compose.yaml"
    Nota

    Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:

  3. Testa il componente per verificare che funzioni come previsto.

    Importante

    È necessario installare e avviare il demone Docker prima di distribuire il componente.

    Dopo aver distribuito il componente localmente, puoi eseguire il comando docker container ls per verificare che il contenitore funzioni.

    docker container ls

  4. Quando il componente è pronto, caricalo su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta Pubblica componenti da distribuire sui tuoi dispositivi principali.

Esegui un contenitore Docker da un'immagine privata in Amazon ECR

Questa sezione descrive come creare un componente personalizzato che esegue un contenitore Docker da un'immagine Docker archiviata in un repository privato in Amazon ECR.

Per eseguire un contenitore Docker

  1. Crea un componente personalizzato sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:

    • Il componente Docker Application Manager come dipendenza. Questo componente consente di AWS IoT Greengrass gestire le credenziali per scaricare immagini da archivi privati.

    • Il componente del servizio di scambio di token come dipendenza. Questo componente consente di AWS IoT Greengrass recuperare AWS le credenziali per interagire con Amazon ECR.

    • Un elemento componente che specifica un'immagine Docker in un repository Amazon ECR privato.

    • Uno script di esecuzione del ciclo di vita che utilizza docker run per creare e avviare un contenitore dall'immagine.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyPrivateDockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from a private Amazon ECR image.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.DockerApplicationManager": {
      "VersionRequirement": "~2.0.0"
    },
    "aws.greengrass.TokenExchangeService": {
      "VersionRequirement": "~2.0.0"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "run": "docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
      },
      "Artifacts": [
        {
          "URI": "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyPrivateDockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from a private Amazon ECR image.'
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.DockerApplicationManager:
    VersionRequirement: ~2.0.0
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ~2.0.0
Manifests:
  - Platform:
      os: all
    Lifecycle:
        run: docker run account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]
    Artifacts:
      - URI: "docker:account-id.dkr.ecr.region.amazonaws.com/repository[:tag|@digest]"
    Nota

    Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:

  2. Testa il componente per verificare che funzioni come previsto.

    Importante

    È necessario installare e avviare il demone Docker prima di distribuire il componente.

    Dopo aver distribuito il componente localmente, puoi eseguire il comando docker container ls per verificare che il contenitore funzioni.

    docker container ls

  3. Carica il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta Pubblica componenti da distribuire sui tuoi dispositivi principali.

Esegui un contenitore Docker da un'immagine in Amazon S3

Questa sezione descrive come eseguire un contenitore Docker in un componente da un'immagine Docker archiviata in Amazon S3.

Per eseguire un contenitore Docker in un componente da un'immagine in Amazon S3

  1. Esegui il comando docker save per creare un backup di un contenitore Docker. Fornisci questo backup come elemento componente su cui eseguire il contenitore. AWS IoT Greengrass Sostituisci hello-world con il nome dell'immagine e sostituisci hello-world.tar con il nome del file di archivio da creare.

    docker save hello-world > artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

  2. Crea un componente personalizzato sul tuo dispositivo AWS IoT Greengrass principale. Usa la seguente ricetta di esempio, che ha le seguenti proprietà:

    • Uno script di installazione del ciclo di vita che utilizza docker load per caricare un'immagine Docker da un archivio.

    • Uno script di esecuzione del ciclo di vita che utilizza docker run per creare e avviare un contenitore dall'immagine. L'--rmopzione pulisce il contenitore quando esce.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      }
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    Nota

    Per utilizzare la comunicazione tra processi (IPC), AWS le credenziali o lo stream manager nel componente del contenitore Docker, devi specificare opzioni aggiuntive quando esegui il contenitore Docker. Per ulteriori informazioni, consulta gli argomenti seguenti:

  3. Testa il componente per verificare che funzioni come previsto.

    Dopo aver distribuito il componente localmente, puoi eseguire il comando docker container ls per verificare che il contenitore funzioni.

    docker container ls

  4. Quando il componente è pronto, carica l'archivio di immagini Docker in un bucket S3 e aggiungi il relativo URI alla ricetta del componente. Quindi, puoi caricare il componente su per AWS IoT Greengrass distribuirlo su altri dispositivi principali. Per ulteriori informazioni, consulta Pubblica componenti da distribuire sui tuoi dispositivi principali.

    Al termine, la ricetta del componente dovrebbe essere simile all'esempio seguente.

    JSON
    {
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.MyS3DockerComponent",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "A component that runs a Docker container from an image in an S3 bucket.",
  "ComponentPublisher": "Amazon",
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": {
          "Script": "docker load -i {artifacts:path}/hello-world.tar"
        },
        "run": {
          "Script": "docker run --rm hello-world"
        }
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar"
        }
      ]
    }
  ]
}
    YAML
    ---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.MyS3DockerComponent
ComponentVersion: '1.0.0'
ComponentDescription: 'A component that runs a Docker container from an image in an S3 bucket.'
ComponentPublisher: Amazon
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install:
        Script: docker load -i {artifacts:path}/hello-world.tar
      run:
        Script: docker run --rm hello-world
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.MyDockerComponent/1.0.0/hello-world.tar

Usa la comunicazione tra processi nei componenti del contenitore Docker

È possibile utilizzare la libreria di comunicazione interprocesso (IPC) di Greengrass SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti Greengrass e. AWS IoT Core Per ulteriori informazioni, consulta Usa il SDK per dispositivi AWS IoT per comunicare con il nucleo Greengrass, altri componenti e AWS IoT Core.

Per utilizzare IPC in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:

  • Montate il socket IPC nel contenitore. Il nucleo Greengrass fornisce il percorso del file socket IPC nella variabile di ambiente. AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT

  • Imposta le variabili SVCUID e di AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT ambiente sui valori che il nucleo Greengrass fornisce ai componenti. Il componente utilizza queste variabili di ambiente per autenticare le connessioni al nucleo Greengrass.

Esempio Ricetta di esempio: pubblica un messaggio MQTT su AWS IoT Core (Python)

La seguente ricetta definisce un componente contenitore Docker di esempio su cui pubblica un messaggio MQTT. AWS IoT Core La ricetta ha le seguenti proprietà:

  • Una politica di autorizzazione (accessControl) che consente al componente di pubblicare messaggi MQTT su tutti gli AWS IoT Core argomenti. Per ulteriori informazioni, vedere Autorizza i componenti a eseguire operazioni IPC Autorizzazione IPC AWS IoT Core MQTT.

  • Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.

  • Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.

  • Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando Docker run ha i seguenti argomenti:

    • L'-vargomento monta il socket IPC Greengrass nel contenitore.

    • I primi due -e argomenti impostano le variabili di ambiente richieste nel contenitore Docker.

    • -eGli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.

    • L'--rmargomento pulisce il contenitore quando esce.

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.PublishToIoTCore",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Uses interprocess communication to publish an MQTT message to IoT Core.",
  "ComponentPublisher": "Amazon",
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "topic": "test/topic/java",
      "message": "Hello, World!",
      "qos": "1",
      "accessControl": {
        "aws.greengrass.ipc.mqttproxy": {
          "com.example.python.docker.PublishToIoTCore:pubsub:1": {
            "policyDescription": "Allows access to publish to IoT Core on all topics.",
            "operations": [
              "aws.greengrass#PublishToIoTCore"
            ],
            "resources": [
              "*"
            ]
          }
        }
      }
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "all"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/publish-to-iot-core.tar",
        "run": "docker run -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e SVCUID -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT -e MQTT_TOPIC=\"{configuration:/topic}\" -e MQTT_MESSAGE=\"{configuration:/message}\" -e MQTT_QOS=\"{configuration:/qos}\" --rm publish-to-iot-core"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.PublishToIoTCore
ComponentVersion: 1.0.0
ComponentDescription: Uses interprocess communication to publish an MQTT message to IoT Core.
ComponentPublisher: Amazon
ComponentConfiguration:
  DefaultConfiguration:
    topic: 'test/topic/java'
    message: 'Hello, World!'
    qos: '1'
    accessControl:
      aws.greengrass.ipc.mqttproxy:
        'com.example.python.docker.PublishToIoTCore:pubsub:1':
          policyDescription: Allows access to publish to IoT Core on all topics.
          operations:
            - 'aws.greengrass#PublishToIoTCore'
          resources:
            - '*'
Manifests:
  - Platform:
      os: all
    Lifecycle:
      install: 'docker load -i {artifacts:path}/publish-to-iot-core.tar'
      run: |
        docker run \
          -v $AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT:$AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
          -e SVCUID \
          -e AWS_GG_NUCLEUS_DOMAIN_SOCKET_FILEPATH_FOR_COMPONENT \
          -e MQTT_TOPIC="{configuration:/topic}" \
          -e MQTT_MESSAGE="{configuration:/message}" \
          -e MQTT_QOS="{configuration:/qos}" \
          --rm publish-to-iot-core
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.PublishToIoTCore/1.0.0/publish-to-iot-core.tar

Usa AWS le credenziali nei componenti del contenitore Docker (Linux)

È possibile utilizzare il componente del servizio di scambio di token per interagire con AWS i servizi nei componenti Greengrass. Questo componente fornisce AWS le credenziali derivanti dal ruolo di scambio di token del dispositivo principale utilizzando un server container locale. Per ulteriori informazioni, consulta Interagisci con AWS i servizi.

Nota

L'esempio in questa sezione funziona solo su dispositivi core Linux.

Per utilizzare AWS le credenziali del servizio di scambio di token in un componente del contenitore Docker, è necessario eseguire il contenitore Docker con i seguenti parametri:

  • Fornisci l'accesso alla rete host utilizzando l'argomento. --network=host Questa opzione consente al contenitore Docker di connettersi al servizio di scambio di token locale per recuperare AWS le credenziali. Questo argomento funziona solo su Docker per Linux.

    avvertimento

    Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta Network: host nella documentazione Docker.

  • Imposta le variabili AWS_CONTAINER_CREDENTIALS_FULL_URI e di AWS_CONTAINER_AUTHORIZATION_TOKEN ambiente sui valori che il nucleo Greengrass fornisce ai componenti. AWS Gli SDK utilizzano queste variabili di ambiente per recuperare AWS le credenziali.

Esempio Ricetta di esempio: elenca i bucket S3 in un componente contenitore Docker (Python)

La seguente ricetta definisce un esempio di componente del contenitore Docker che elenca i bucket S3 presenti nel tuo. Account AWS La ricetta ha le seguenti proprietà:

  • Il componente del servizio di scambio di token come dipendenza. Questa dipendenza consente al componente di recuperare le AWS credenziali per interagire con altri servizi. AWS

  • Un elemento componente che specifica un'immagine Docker come archivio tar in Amazon S3.

  • Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.

  • Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando Docker run ha i seguenti argomenti:

    • L'--network=hostargomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al servizio di scambio di token.

    • L'-eargomento imposta le variabili di ambiente richieste nel contenitore Docker.

    • L'--rmargomento pulisce il contenitore quando esce.

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.ListS3Buckets",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Uses the token exchange service to lists your S3 buckets.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.TokenExchangeService": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/list-s3-buckets.tar",
        "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e AWS_CONTAINER_CREDENTIALS_FULL_URI --rm list-s3-buckets"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.ListS3Buckets
ComponentVersion: 1.0.0
ComponentDescription: Uses the token exchange service to lists your S3 buckets.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.TokenExchangeService:
    VersionRequirement: ^2.0.0
    DependencyType: HARD
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: 'docker load -i {artifacts:path}/list-s3-buckets.tar'
      run: |
        docker run \
          --network=host \
          -e AWS_CONTAINER_AUTHORIZATION_TOKEN \
          -e AWS_CONTAINER_CREDENTIALS_FULL_URI \
          --rm list-s3-buckets
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.ListS3Buckets/1.0.0/list-s3-buckets.tar

Usa lo stream manager nei componenti del contenitore Docker (Linux)

È possibile utilizzare il componente stream manager per gestire i flussi di dati nei componenti Greengrass. Questo componente consente di elaborare flussi di dati e trasferire dati IoT ad alto volume a. Cloud AWS AWS IoT Greengrassfornisce un SDK per la gestione dello stream che puoi utilizzare per interagire con il componente stream manager. Per ulteriori informazioni, consulta Gestisci i flussi di dati sui dispositivi core Greengrass.

Nota

L'esempio in questa sezione funziona solo su dispositivi core Linux.

Per utilizzare lo stream manager SDK in un componente del contenitore Docker, devi eseguire il contenitore Docker con i seguenti parametri:

  • Fornisci l'accesso alla rete host utilizzando l'argomento. --network=host Questa opzione consente al contenitore Docker di interagire con il componente stream manager tramite una connessione TLS locale. Questo argomento funziona solo su Docker per Linux

    avvertimento

    Questa opzione consente al contenitore di accedere a tutte le interfacce di rete locale sull'host, quindi è meno sicura rispetto all'esecuzione di contenitori Docker senza questo accesso alla rete host. Considera questo aspetto quando sviluppi ed esegui componenti del contenitore Docker che utilizzano questa opzione. Per ulteriori informazioni, consulta Network: host nella documentazione Docker.

  • Se configuri il componente stream manager per richiedere l'autenticazione, che è il comportamento predefinito, imposta la variabile di AWS_CONTAINER_CREDENTIALS_FULL_URI ambiente sul valore che il nucleo Greengrass fornisce ai componenti. Per ulteriori informazioni, consulta la configurazione dello stream manager.

  • Se configuri il componente stream manager per utilizzare una porta non predefinita, usa la comunicazione tra processi (IPC) per ottenere la porta dalla configurazione del componente stream manager. È necessario eseguire il contenitore Docker con opzioni aggiuntive per utilizzare IPC. Per ulteriori informazioni, consulta gli argomenti seguenti:

Esempio Ricetta di esempio: trasmetti un file a un bucket S3 in un componente contenitore Docker (Python)

La seguente ricetta definisce un esempio di componente contenitore Docker che crea un file e lo trasmette a un bucket S3. La ricetta ha le seguenti proprietà:

  • Il componente stream manager come dipendenza. Questa dipendenza consente al componente di utilizzare lo stream manager SDK per interagire con il componente stream manager.

  • Un elemento componente che specifica un'immagine Docker come archivio TAR in Amazon S3.

  • Uno script di installazione del ciclo di vita che carica l'immagine Docker dall'archivio TAR.

  • Uno script di esecuzione del ciclo di vita che esegue un contenitore Docker dall'immagine. Il comando Docker run ha i seguenti argomenti:

    • L'--network=hostargomento fornisce al contenitore l'accesso alla rete host, in modo che il contenitore possa connettersi al componente stream manager.

    • Il primo -e argomento imposta la variabile di AWS_CONTAINER_AUTHORIZATION_TOKEN ambiente richiesta nel contenitore Docker.

    • -eGli argomenti aggiuntivi impostano le variabili di ambiente utilizzate in questo esempio.

    • L'-vargomento monta la cartella di lavoro del componente nel contenitore. Questo esempio crea un file nella cartella di lavoro per caricare quel file su Amazon S3 utilizzando stream manager.

    • L'--rmargomento pulisce il contenitore quando esce.

JSON
{
  "RecipeFormatVersion": "2020-01-25",
  "ComponentName": "com.example.python.docker.StreamFileToS3",
  "ComponentVersion": "1.0.0",
  "ComponentDescription": "Creates a text file and uses stream manager to stream the file to S3.",
  "ComponentPublisher": "Amazon",
  "ComponentDependencies": {
    "aws.greengrass.StreamManager": {
      "VersionRequirement": "^2.0.0",
      "DependencyType": "HARD"
    }
  },
  "ComponentConfiguration": {
    "DefaultConfiguration": {
      "bucketName": ""
    }
  },
  "Manifests": [
    {
      "Platform": {
        "os": "linux"
      },
      "Lifecycle": {
        "install": "docker load -i {artifacts:path}/stream-file-to-s3.tar",
        "run": "docker run --network=host -e AWS_CONTAINER_AUTHORIZATION_TOKEN -e BUCKET_NAME=\"{configuration:/bucketName}\" -e WORK_PATH=\"{work:path}\" -v {work:path}:{work:path} --rm stream-file-to-s3"
      },
      "Artifacts": [
        {
          "URI": "s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar"
        }
      ]
    }
  ]
}
YAML
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.python.docker.StreamFileToS3
ComponentVersion: 1.0.0
ComponentDescription: Creates a text file and uses stream manager to stream the file to S3.
ComponentPublisher: Amazon
ComponentDependencies:
  aws.greengrass.StreamManager:
    VersionRequirement: ^2.0.0
    DependencyType: HARD
ComponentConfiguration:
  DefaultConfiguration:
    bucketName: ''
Manifests:
  - Platform:
      os: linux
    Lifecycle:
      install: 'docker load -i {artifacts:path}/stream-file-to-s3.tar'
      run: |
        docker run \
          --network=host \
          -e AWS_CONTAINER_AUTHORIZATION_TOKEN \
          -e BUCKET_NAME="{configuration:/bucketName}" \
          -e WORK_PATH="{work:path}" \
          -v {work:path}:{work:path} \
          --rm stream-file-to-s3
    Artifacts:
      - URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.python.docker.StreamFileToS3/1.0.0/stream-file-to-s3.tar