As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criar implantações
Você pode criar uma implantação que tenha como alvo um objeto ou um grupo de objetos.
Ao criar uma implantação, você configura os componentes de software a serem implantados e como o trabalho de implantação é implementado nos dispositivos de destino. É possível definir a implantação no arquivo JSON que você fornece à AWS CLI.
O destino de implantação determina os dispositivos nos quais você deseja executar os componentes. Para implantar em um dispositivo principal, especifique um objeto. Para implantar em vários dispositivos principais, especifique um grupo de objetos que inclua esses dispositivos. Para mais informações sobre como configurar grupos de objetos, consulte [Grupos de objetos estáticos](https://docs.aws.amazon.com/iot/latest/developerguide/thing-groups.html) e [Grupos de objetos dinâmicos](https://docs.aws.amazon.com/iot/latest/developerguide/dynamic-thing-groups.html) no *Guia do desenvolvedor da AWS IoT*.
Siga as etapas nesta seção para criar uma implantação em um destino. Para mais informações sobre como atualizar os componentes de software em um destino que tenha uma implantação, consulte [Revisões das implantações](revise-deployments.md).
**Atenção**
A operação [CreateDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateDeployment.html) pode desinstalar componentes dos dispositivos principais. Se um componente estiver presente na implantação anterior e não na nova implantação, o dispositivo principal desinstalará esse componente. Para evitar a desinstalação de componentes, primeiro use a operação [ListDeployments](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_ListDeployments.html) para verificar se o destino da implantação já tem uma implantação existente. Em seguida, use a operação [GetDeployment](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_GetDeployment.html) para começar a partir dessa implantação existente ao criar uma nova implantação.
**Para criar uma implantação (AWS CLI)**
1. Crie um arquivo chamado `deployment.json` e copie o objeto JSON a seguir no arquivo. Substitua *targetArn* pelo ARN do objeto ou grupo de objetos da AWS IoT a ser direcionado para a implantação. Os ARNs de objetos e de grupos de objetos têm o seguinte formato:
+ Coisa: `arn:aws:iot:region:account-id:thing/thingName`
+ Grupo de coisas: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
```
{
"targetArn": "targetArn"
}
```
1. Verifique se o destino de implantação tem uma implantação existente que você deseja revisar. Faça o seguinte:
1. Execute o comando a seguir para listar as implantações para o destino de implantação. Substitua *targetArn* pelo ARN do objeto da AWS IoT de destino ou pelo grupo de objetos.
```
aws greengrassv2 list-deployments --target-arn targetArn
```
A resposta contém uma lista com a implantação mais recente do destino. Se a resposta está vazia, o destino não tem uma implantação existente e você pode pular para [Step 3](#create-deployment-define-name-step). Caso contrário, copie o `deploymentId` da resposta para usar na próxima etapa.
**nota**
Também é possível revisar uma implantação diferente da revisão mais recente do destino. Especifique o argumento `--history-filter ALL` para listar todas as implantações do destino. Em seguida, copie o ID da implantação que você quer revisar.
1. Execute o comando a seguir para obter os detalhes da implantação. Esses detalhes incluem metadados, componentes e configuração do trabalho. Substitua *deploymentId* pelo ID da etapa anterior.
```
aws greengrassv2 get-deployment --deployment-id deploymentId
```
A resposta tem os detalhes da implantação.
1. Copie qualquer um dos seguintes pares de valores-chave da resposta do comando anterior para `deployment.json`. Você pode alterar esses valores para a nova implantação.
+ `deploymentName`: o nome da implantação.
+ `components`: os componentes da implantação. Para desinstalar um componente, remova-o desse objeto.
+ `deploymentPolicies`: as políticas da implantação.
+ `iotJobConfiguration`: a configuração do trabalho da implantação.
+ `tags`: as tags da implantação.
1. (Opcional) Defina um nome para a implantação. Substitua *deploymentName* pelo nome da implantação.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName"
}
```
1. Adicione cada componente para implantar os dispositivos de destino. Para fazer isso, adicione pares de chave-valor ao objeto `components`, em que a chave é o nome do componente e o valor é um objeto que contém os detalhes desse componente. Especifique os seguintes detalhes para cada componente adicionado:
+ `version`: a versão do componente a ser implantada.
+ `configurationUpdate`: a [atualização de configuração](update-component-configurations.md) a ser implantada. A atualização é uma operação de patch que modifica a configuração existente do componente em cada dispositivo de destino ou a configuração padrão do componente se ela não existir no dispositivo de destino. Você pode especificar as seguintes atualizações de configuração:
+ Redefinir atualizações (`reset`): (opcional) uma lista de ponteiros JSON que definem os valores de configuração a serem redefinidos para seus valores padrão no dispositivo de destino. O software AWS IoT Greengrass Core aplica as atualizações de redefinição antes da aplicação das atualizações de mesclagem. Para obter mais informações, consulte [Atualizações de redefinição](update-component-configurations.md#reset-configuration-update).
+ Mesclar atualizações (`merge`): (opcional) um documento JSON que define os valores de configuração a serem mesclados no dispositivo de destino. Serialize o documento JSON como uma string. Para obter mais informações, consulte [Atualizações de mesclagem](update-component-configurations.md#merge-configuration-update).
+ `runWith`: (opcional) as opções de processo do sistema que o software AWS IoT Greengrass Core usa para executar os processos desse componente no dispositivo principal. Se você omitir um parâmetro no objeto `runWith`, o software AWS IoT Greengrass Core usará os valores padrão que você configurar no [componente do núcleo do Greengrass](greengrass-nucleus-component.md).
Você pode especificar qualquer uma das seguintes opções:
+ `posixUser`: o usuário do sistema POSIX e, como opção, o grupo a ser usado para executar este componente em dispositivos principais do Linux. O usuário e o grupo, se especificados, devem existir em cada dispositivo principal do Linux. Especifique o usuário e o grupo separando-os por dois pontos (`:`), no seguinte formato: `user:group`. O grupo é opcional. Caso um grupo não seja especificado, o software AWS IoT Greengrass Core usará o grupo primário para o usuário. Para obter mais informações, consulte [Configurar o usuário que executa os componentes](configure-greengrass-core-v2.md#configure-component-user).
+ `windowsUser`: o usuário do Windows a ser usado para executar esse componente nos dispositivos principais do Windows. O usuário deve existir em cada dispositivo principal do Windows e seu nome e senha devem estar armazenados na instância do gerenciador de credenciais da conta LocalSystem. Para obter mais informações, consulte [Configurar o usuário que executa os componentes](configure-greengrass-core-v2.md#configure-component-user).
Esse atributo está disponível para a versão 2.5.0 e posterior do [componente de núcleo do Greengrass](greengrass-nucleus-component.md).
+ `systemResourceLimits`: os limites de recursos do sistema a serem aplicados aos processos desse componente. Você pode aplicar limites de recursos do sistema a componentes Lambda genéricos e não conteinerizados. Para obter mais informações, consulte [Configurar limites de recursos do sistema para componentes](configure-greengrass-core-v2.md#configure-component-system-resource-limits).
Você pode especificar qualquer uma das seguintes opções:
+ `cpus`: a quantidade máxima de tempo de CPU que os processos deste componente podem usar no dispositivo principal. O tempo total da CPU de um dispositivo essencial é equivalente ao número de núcleos da CPU do dispositivo. Por exemplo, em um dispositivo principal com quatro núcleos da CPU, é possível definir esse valor como `2` a fim de limitar os processos do componente para 50% de uso em cada núcleo da CPU. Em um dispositivo com um núcleo da CPU, você pode definir esse valor como `0.25` a fim de limitar os processos do componente para 25% de uso da CPU. Caso o valor definido seja um número maior que o número de núcleos da CPU, o software AWS IoT Greengrass Core não limitará o uso da CPU do componente.
+ `memory`: a quantidade máxima de RAM, expressa em kilobytes, que esse processo de componente pode usar no dispositivo principal.
Esse atributo está disponível na versão 2.4.0 e posteriores do [componente do núcleo do Greengrass](greengrass-nucleus-component.md). Atualmente, o AWS IoT Greengrass não é compatível com esse atributo nos dispositivos principais do Windows.
**Example Exemplo de atualização de configuração básica**
O seguinte objeto `components` de exemplo especifica a implantação de um componente, `com.example.PythonRuntime`, que espera um parâmetro de configuração chamado `pythonVersion`.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.PythonRuntime": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"pythonVersion\":\"3.7\"}"
}
}
}
}
```
**Example Exemplo de atualização de configuração com atualizações de redefinição e mesclagem**
Considere um exemplo de componente de painel industrial, `com.example.IndustrialDashboard`, que tem a seguinte configuração padrão.
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
A atualização de configuração a seguir especifica as seguintes instruções:
1. Redefina a configuração HTTPS para o valor padrão (`true`).
1. Redefina a lista de etiquetas industriais para uma lista vazia.
1. Combine uma lista de etiquetas industriais que identificam fluxos de dados de temperatura e pressão para duas caldeiras.
```
{
"reset": [
"/network/useHttps",
"/tags"
],
"merge": {
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
```
O seguinte objeto `components` de exemplo especifica a implantação desse componente de painel industrial e a atualização de configuração.
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
1. (Opcional) Defina políticas para a implantação. Você pode configurar quando os dispositivos principais podem aplicar uma implantação com segurança ou o que fazer se um dispositivo principal não conseguir aplicar a implantação. Para isso, adicione um objeto `deploymentPolicies` ao `deployment.json` e, em seguida, faça o seguinte:
1. (Opcional) Especifique a política de atualização de componente (`componentUpdatePolicy`). Essa política define se a implantação permite ou não que os componentes adiem uma atualização até que estejam prontos para serem atualizados. Por exemplo, os componentes podem precisar limpar recursos ou concluir ações críticas antes de serem reiniciados para aplicar uma atualização. Essa política também define a quantidade de tempo que os componentes têm para responder a uma notificação de atualização.
Esta política é um objeto com os seguintes parâmetros:
+ `action`: (opcional) notifica, ou não, os componentes e aguarda que eles possam informar quando estiverem prontos para atualização. Escolha uma das seguintes opções:
+ `NOTIFY_COMPONENTS`: a implantação notifica cada componente antes que ele seja interrompido e atualiza esse componente. Os componentes podem usar a operação de IPC [SubscribeToComponentUpdates](ipc-component-lifecycle.md#ipc-operation-subscribetocomponentupdates) para receber essas notificações.
+ `SKIP_NOTIFY_COMPONENTS`: a implantação não notifica os componentes ou aguarda que eles possam ser atualizados com segurança.
O padrão é `NOTIFY_COMPONENTS`.
+ `timeoutInSeconds`: a quantidade de tempo, em segundos, que cada componente tem para responder a uma notificação de atualização com a operação de IPC [DeferComponentUpdate](ipc-component-lifecycle.md#ipc-operation-defercomponentupdate). Se o componente não responder dentro desse período, a implantação prosseguirá no dispositivo principal.
O padrão é 60 segundos.
1. (Opcional) Especifique a política de validação de configuração (`configurationValidationPolicy`). Esta política define quanto tempo cada componente tem para validar uma atualização de configuração de uma implantação. Os componentes podem usar a operação de IPC [SubscribeToValidateConfigurationUpdates](ipc-component-configuration.md#ipc-operation-subscribetovalidateconfigurationupdates) para assinar notificações para as próprias atualizações de configuração. Em seguida, os componentes podem usar a operação de IPC [SendConfigurationValidityReport](ipc-component-configuration.md#ipc-operation-sendconfigurationvalidityreport) para informar ao software AWS IoT Greengrass Core se a atualização de configuração é válida. Se a atualização de configuração não for válida, a implantação falhará.
Esta política é um objeto com o seguinte parâmetro:
+ `timeoutInSeconds` (Opcional) a quantidade de tempo em segundos que cada componente tem para validar uma atualização de configuração. Se o componente não responder dentro desse período, a implantação prosseguirá no dispositivo principal.
O padrão é 30 segundos.
1. (Opcional) Especifique a política de tratamento de falhas (`failureHandlingPolicy`). Essa política é uma sequência de caracteres que define se os dispositivos devem ser revertidos ou não se a implantação falhar. Escolha uma das seguintes opções:
+ `ROLLBACK`: se a implantação falhar em um dispositivo principal, o software AWS IoT Greengrass Core reverterá esse dispositivo principal para a configuração anterior.
+ `DO_NOTHING`: se a implantação falhar em um dispositivo principal, o software AWS IoT Greengrass Core manterá a nova configuração. Isso pode resultar em componentes com falha se a nova configuração não for válida.
O padrão é `ROLLBACK`.
Sua implantação em `deployment.json` pode ser semelhante ao exemplo a seguir:
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
}
}
```
1. (Opcional) Defina como a implantação é interrompida, implementada ou expira. O AWS IoT Greengrass usa trabalhos do AWS IoT Core para enviar implantações aos dispositivos principais, portanto, essas opções são idênticas às opções de configuração dos trabalhos do AWS IoT Core. Para mais informações, consulte [Configuração para implantar e anular trabalhos](https://docs.aws.amazon.com/iot/latest/developerguide/job-rollout-abort.html) no *Guia do desenvolvedor da AWS IoT*.
Para definir as opções de trabalho, adicione um objeto `iotJobConfiguration` ao `deployment.json`. Em seguida, defina as opções a serem configuradas.
Sua implantação em `deployment.json` pode ser semelhante ao exemplo a seguir:
```
{
"targetArn": "targetArn",
"deploymentName": "deploymentName",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
},
"deploymentPolicies": {
"componentUpdatePolicy": {
"action": "NOTIFY_COMPONENTS",
"timeoutInSeconds": 30
},
"configurationValidationPolicy": {
"timeoutInSeconds": 60
},
"failureHandlingPolicy": "ROLLBACK"
},
"iotJobConfiguration": {
"abortConfig": {
"criteriaList": [
{
"action": "CANCEL",
"failureType": "ALL",
"minNumberOfExecutedThings": 100,
"thresholdPercentage": 5
}
]
},
"jobExecutionsRolloutConfig": {
"exponentialRate": {
"baseRatePerMinute": 5,
"incrementFactor": 2,
"rateIncreaseCriteria": {
"numberOfNotifiedThings": 10,
"numberOfSucceededThings": 5
}
},
"maximumPerMinute": 50
},
"timeoutConfig": {
"inProgressTimeoutInMinutes": 5
}
}
}
```
1. (Opcional) Adicione tags (`tags`) à implantação. Para obter mais informações, consulte [Marque seus AWS IoT Greengrass Version 2 recursos](tag-resources.md).
1. Execute o seguinte comando para criar uma estratégia de implantação do `deployment.json`.
```
aws greengrassv2 create-deployment --cli-input-json file://deployment.json
```
A resposta inclui um `deploymentId` que identifica essa implantação. Você pode usar o ID de implantação para verificar o status dela. Para obter mais informações, consulte [Verificar o status da implantação](check-deployment-status.md#check-cloud-deployment-status).
# Atualizar configurações do componente
As configurações de componente são objetos JSON que definem os parâmetros de cada componente. A fórmula de cada componente define sua configuração padrão, que você modifica ao implantar componentes em dispositivos principais.
Ao criar uma implantação, você pode especificar a *atualização de configuração* que será aplicada a cada componente. As atualizações de configuração são operações de patch, ou seja, a atualização modifica a configuração do componente que existe no dispositivo principal. Se o dispositivo principal não tiver o componente, a atualização de configuração modificará e aplicará a configuração padrão a essa implantação.
A atualização de configuração define atualizações de *redefinição* e de *mesclagem*. As atualizações de redefinição determinam os valores de configuração que devem ser redefinidos aos padrões ou removidos. As atualizações de mesclagem determinam os novos valores de configuração que serão definidos no componente. Quando você implanta uma atualização de configuração, o software AWS IoT Greengrass Core executa a atualização de redefinição antes da atualização de mesclagem.
Os componentes podem validar as atualizações de configuração que você implanta. O componente faz a assinatura para receber uma notificação quando a implantação altera sua configuração e pode rejeitar uma configuração à qual não ofereça suporte. Para obter mais informações, consulte [Interagir com a configuração do componente](ipc-component-configuration.md).
**Topics**
+ [Atualizações de redefinição](#reset-configuration-update)
+ [Atualizações de mesclagem](#merge-configuration-update)
+ [Exemplos](#configuration-update-example)
## Atualizações de redefinição
As atualizações de redefinição determinam os valores que devem ser redefinidos aos padrões no dispositivo principal. Se um valor de configuração não tiver um padrão, a atualização de redefinição o removerá da configuração do componente. Isso pode ajudar você a corrigir um componente com falha por causa de uma configuração inválida.
Use uma lista de ponteiros JSON para determinar os valores de configuração que devem ser redefinidos. Os ponteiros JSON começam com uma barra `/`. Para identificar um valor em uma configuração de componente aninhado, use barras (`/`) para separar as chaves de cada nível na configuração. Para obter mais informações, consulte a [Especificação de ponteiros JSON](https://tools.ietf.org/html/rfc6901) (em inglês).
**nota**
Você pode redefinir somente uma lista inteira aos valores padrão. Você não pode usar as atualizações de redefinição para redefinir apenas um elemento de uma lista.
Para redefinir toda a configuração de um componente aos valores padrão, especifique uma única string vazia como a atualização de redefinição.
```
"reset": [""]
```
## Atualizações de mesclagem
As atualizações de mesclagem definem os valores de configuração que serão inseridos na configuração do componente no núcleo. A atualização de mesclagem é um objeto JSON que o software AWS IoT Greengrass Core mescla depois de redefinir os valores nos caminhos que você especifica na atualização de redefinição. Ao usar o AWS CLI ou AWS SDKs, você deve serializar esse objeto JSON como uma string.
Você pode mesclar um par de chave/valor que não existe na configuração padrão do componente. Você também pode mesclar um par de chave/valor que tenha um tipo diferente do valor com a mesma chave. O novo valor substitui o valor antigo. Isso significa que você pode alterar a estrutura do objeto de configuração.
Você pode mesclar valores nulos e strings, listas e objetos vazios.
**nota**
Você não pode usar atualizações de mesclagem com a finalidade de inserir ou anexar um elemento a uma lista. Você pode substituir uma lista inteira ou definir um objeto em que cada elemento tenha uma chave exclusiva.
AWS IoT Greengrass usa JSON para valores de configuração. O JSON especifica um tipo de número, mas não diferencia entre números inteiros e flutuantes. Como resultado, os valores de configuração podem ser convertidos em flutuantes no AWS IoT Greengrass. Para garantir que seu componente use o tipo de dados correto, recomendamos que você defina valores de configuração numéricos como strings. Em seguida, faça com que seu componente os analise como números inteiros ou flutuantes. Isso garante que seus valores de configuração tenham o mesmo tipo na configuração e no seu dispositivo principal.
### Usar variáveis de fórmula em atualizações de mesclagem
Esse recurso está disponível para a versão 2.6.0 e posterior do [componente de núcleo do Greengrass](greengrass-nucleus-component.md).
Se você definir a opção de [interpolateComponentConfiguration](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-interpolate-component-configuration)configuração do núcleo do Greengrass como`true`, poderá usar variáveis de receita, além da variável de `component_dependency_name:configuration:json_pointer` receita, em atualizações de mesclagem. Por exemplo, você pode usar a variável de `{iot:thingName}` receita em uma atualização de mesclagem para incluir o nome do item do AWS IoT dispositivo principal em um valor de configuração do componente, como uma política de autorização de [comunicação entre processos (IPC)](interprocess-communication.md#ipc-authorization-policies).
## Exemplos
O exemplo a seguir demonstra as atualizações de configuração para um componente do painel que tem a configuração padrão abaixo. Este componente de exemplo exibe informações sobre equipamentos industriais.
```
{
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
```
### Fórmula de componente do painel industrial
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.IndustrialDashboard",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Displays information about industrial equipment.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"name": null,
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 80,
"https": 443
},
},
"tags": []
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/industrial_dashboard.py"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/industrial_dashboard.py"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.IndustrialDashboard
ComponentVersion: '1.0.0'
ComponentDescription: Displays information about industrial equipment.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
name: null
mode: REQUEST
network:
useHttps: true
port:
http: 80
https: 443
tags: []
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/industrial_dashboard.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/industrial_dashboard.py
```
------
**Example Exemplo 1: atualização de mesclagem**
Você cria uma implantação que aplica a atualização de configuração a seguir, que especifica uma atualização de mesclagem, mas não uma atualização de redefinição. Essa atualização de configuração instrui o componente a exibir o painel na porta HTTP 8080 com os dados de duas caldeiras.
**Configuração a ser mesclada**
```
{
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
O comando a seguir cria uma implantação em um dispositivo principal.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment.json
```
O arquivo `dashboard-deployment.json` contém o documento JSON a seguir.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"name\":\"Factory 2A\",\"network\":{\"useHttps\":false,\"port\":{\"http\":8080}},\"tags\":[\"/boiler/1/temperature\",\"/boiler/1/pressure\",\"/boiler/2/temperature\",\"/boiler/2/pressure\"]}"
}
}
}
}
```
O comando da [CLI do Greengrass](greengrass-cli-component.md) a seguir cria uma implantação local em um dispositivo principal.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration.json
```
O arquivo `dashboard-configuration.json` contém o documento JSON a seguir.
```
{
"com.example.IndustrialDashboard": {
"MERGE": {
"name": "Factory 2A",
"network": {
"useHttps": false,
"port": {
"http": 8080
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
}
}
```
Após essa atualização, o componente do painel terá a configuração abaixo.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": false,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/1/temperature",
"/boiler/1/pressure",
"/boiler/2/temperature",
"/boiler/2/pressure"
]
}
```
**Example Exemplo 2: redefinir e mesclar atualizações**
Em seguida, você cria uma implantação que aplica a atualização de configuração a seguir, que especifica uma atualização de redefinição e uma de mesclagem. Essas atualizações especificam a exibição do painel na porta HTTPS padrão com os dados das caldeiras diferentes. Essas atualizações modificam a configuração resultante das atualizações de configuração no exemplo anterior.
**Caminhos de redefinição**
```
[
"/network/useHttps",
"/tags"
]
```
**Configuração a ser mesclada**
```
{
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
```
O comando a seguir cria uma implantação em um dispositivo principal.
```
aws greengrassv2 create-deployment --cli-input-json file://dashboard-deployment2.json
```
O arquivo `dashboard-deployment2.json` contém o documento JSON a seguir.
```
{
"targetArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"deploymentName": "Deployment for MyGreengrassCore",
"components": {
"com.example.IndustrialDashboard": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"reset": [
"/network/useHttps",
"/tags"
],
"merge": "{\"tags\":[\"/boiler/3/temperature\",\"/boiler/3/pressure\",\"/boiler/4/temperature\",\"/boiler/4/pressure\"]}"
}
}
}
}
```
O comando da [CLI do Greengrass](greengrass-cli-component.md) a seguir cria uma implantação local em um dispositivo principal.
```
sudo greengrass-cli deployment create \
--recipeDir recipes \
--artifactDir artifacts \
--merge "com.example.IndustrialDashboard=1.0.0" \
--update-config dashboard-configuration2.json
```
O arquivo `dashboard-configuration2.json` contém o documento JSON a seguir.
```
{
"com.example.IndustrialDashboard": {
"RESET": [
"/network/useHttps",
"/tags"
],
"MERGE": {
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure"
]
}
}
}
```
Após essa atualização, o componente do painel terá a configuração abaixo.
```
{
"name": "Factory 2A",
"mode": "REQUEST",
"network": {
"useHttps": true,
"port": {
"http": 8080,
"https": 443
}
},
"tags": [
"/boiler/3/temperature",
"/boiler/3/pressure",
"/boiler/4/temperature",
"/boiler/4/pressure",
]
}
```