Aviso de fim do suporte: em 7 de outubro de 2026, AWS encerrará o suporte para AWS Proton. Depois de 7 de outubro de 2026, você não poderá mais acessar o AWS Proton console ou os AWS Proton recursos. Sua infraestrutura implantada permanecerá intacta. Para obter mais informações, consulte o Guia [AWS Proton de descontinuação e migração de serviços](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html).
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á.
# AWS Proton modelos
Para adicionar seu pacote de modelos à sua biblioteca AWS Proton de modelos, crie uma versão secundária de modelos e registre-a com AWS Proton. Ao criar o modelo, forneça o nome do bucket do Amazon S3 e o caminho para o pacote de modelo. Depois que os modelos são publicados, eles podem ser selecionados pelos membros da equipe da plataforma e pelos desenvolvedores. Depois de selecionados, AWS Proton usa o modelo para criar e provisionar infraestrutura e aplicativos.
Como administrador, você pode criar e registrar um modelo de ambiente com AWS Proton. Esse modelo de ambiente pode então ser usado para implantar vários ambientes. Por exemplo, ele pode ser usado para implantar ambientes de “desenvolvimento”, “teste” e “produção”. O ambiente “dev” (ambiente de desenvolvimento) pode incluir uma VPC com sub-redes privadas e uma política de acesso restritiva a todos os recursos. As saídas do ambiente podem ser usadas como entradas para serviços.
Você pode criar e registrar modelos de ambiente para criar dois tipos diferentes de ambientes. Você e os desenvolvedores podem usar AWS Proton para implantar serviços em ambos os tipos.
+ Registre e publique um modelo de ambiente *padrão* AWS Proton usado para criar um ambiente *padrão* que provisione e gerencie a infraestrutura do ambiente.
+ Registre e publique um modelo de ambiente *gerenciado pelo cliente* que AWS Proton use para criar um ambiente gerenciado pelo cliente que se conecte à sua infraestrutura provisionada existente. AWS Proton *não* gerencia sua infraestrutura provisionada existente.
Você pode criar e registrar modelos de serviço AWS Proton para implantar serviços em ambientes. Um AWS Proton ambiente deve ser criado antes que um serviço possa ser implantado nele.
A lista a seguir descreve como você cria e gerencia modelos com AWS Proton.
+ (Opcional) Prepare uma função do IAM para controlar o acesso do desenvolvedor às chamadas de AWS Proton API e às funções de serviço AWS Proton do IAM. Para obter mais informações, consulte [Perfis do IAM](ag-environment-roles.md).
+ Compor um pacote de modelos. Para obter mais informações, consulte [Pacotes de modelos](ag-template-authoring.md#ag-template-bundles).
+ Crie e registre um modelo AWS Proton depois que o pacote de modelos for composto, compactado e salvo em um bucket do Amazon S3. Você pode fazer isso no console ou usando o AWS CLI.
+ Teste e use o modelo para criar e gerenciar recursos AWS Proton provisionados após seu registro no. AWS Proton
+ Crie e gerencie versões principais e secundárias do modelo durante toda a vida útil do modelo.
Você pode gerenciar versões de modelos manualmente ou com configurações de sincronização de modelos:
+ Use o AWS Proton console e AWS CLI crie uma nova versão secundária ou principal.
+ [Crie uma configuração de sincronização de modelos](create-template-sync.md) que permita criar AWS Proton automaticamente uma nova versão secundária ou principal ao detectar uma alteração no seu pacote de modelos em um repositório definido por você.
Para obter informações adicionais, consulte [https://docs.aws.amazon.com/proton/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/proton/latest/APIReference/Welcome.html).
**Topics**
+ [Modelos versionados](ag-template-versions.md)
+ [Registre e publique modelos](template-create.md)
+ [Visualizar dados do modelo](template-view.md)
+ [Atualizar um modelo](template-update.md)
+ [Excluir modelos](template-delete.md)
+ [Configurações de sincronização de modelo](ag-template-sync-configs.md)
+ [Configurações de sincronização de serviços](ag-service-sync-configs.md)
# Modelos versionados
Como administrador ou membro de uma equipe da plataforma, você define, cria e gerencia uma biblioteca de modelos versionados que são usados para provisionar recursos de infraestrutura. Há dois tipos de versões de modelo: versões secundárias e versões principais.
+ *Versões secundárias*: Alterações no modelo que têm um esquema compatível com versões anteriores. Essas alterações não exigem que o desenvolvedor forneça novas informações ao atualizar para a nova versão do modelo.
Ao tentar fazer uma pequena alteração na AWS Proton versão, tente ao máximo determinar se o esquema da nova versão é compatível com versões anteriores do modelo. Se o novo esquema não for compatível com versões anteriores, o registro da nova versão secundária AWS Proton falhará.
**nota**
A compatibilidade é determinada exclusivamente com base no esquema. AWS Proton não verifica se o arquivo de infraestrutura como código (IaC) do pacote de modelos é compatível com versões anteriores secundárias. Por exemplo, AWS Proton não verifica se o novo arquivo IaC causa alterações significativas nos aplicativos que estão sendo executados na infraestrutura provisionada por uma versão secundária anterior do modelo.
+ *Versões principais*: Alterações no modelo que podem não ser compatíveis com versões anteriores. Essas mudanças geralmente exigem novas informações do desenvolvedor e geralmente envolvem mudanças no esquema do modelo.
Às vezes, você pode optar por designar uma alteração compatível com versões anteriores como uma versão principal com base no modelo operacional da sua equipe.
A forma como AWS Proton determina se uma solicitação de versão do modelo é para uma versão secundária ou principal depende da forma como as alterações do modelo são rastreadas:
+ Quando você faz uma solicitação explícita para criar uma nova versão de modelo, solicita uma versão principal especificando um número de versão principal e solicita uma versão secundária sem especificar um número de versão principal.
+ Quando você usa a [sincronização de modelos](ag-template-sync-configs.md) (e, portanto, não faz solicitações explícitas de versão de modelo), AWS Proton tenta criar novas versões secundárias para alterações de modelo que ocorrem no arquivo YAML existente. AWS Proton cria uma versão principal quando você cria um novo diretório para a nova alteração do modelo (por exemplo, mover da v1 para a v2).
**nota**
O registro de uma nova versão secundária com base na sincronização de modelos ainda falhará se AWS Proton determinar que a alteração não é compatível com versões anteriores.
Quando você publica uma nova versão de um modelo, ela se torna a versão **recomendada** se for a versão principal e secundária mais alta. Novos AWS Proton recursos são criados usando a nova versão recomendada e AWS Proton solicita que os administradores usem a nova versão e atualizem os AWS Proton recursos existentes que estão usando uma versão desatualizada.
# Registre e publique modelos
Você pode registrar e publicar modelos de ambiente e serviço com AWS Proton, conforme descrito nas seções a seguir.
Você pode criar uma nova versão de um modelo com o console ou AWS CLI.
Como alternativa, você pode usar o console ou AWS CLI criar um modelo e [configurar uma sincronização de modelo](ag-template-sync-configs.md) para ele. Essa configuração permite a AWS Proton sincronização a partir de pacotes de modelos localizados em repositórios git registrados que você definiu. Sempre que um commit é enviado para seu repositório e isso muda um de seus pacotes de modelos, uma nova versão principal ou secundária de seu modelo é criada, se essa versão já não existir. Para saber mais sobre pré-requisitos e requisitos de configuração de sincronização de modelos, consulte [Configurações de sincronização de modelo](ag-template-sync-configs.md).
## Registrar e publicar modelos de ambiente
Você pode registrar e publicar os seguintes tipos de modelos de ambiente.
+ Registre e publique um modelo de ambiente *padrão* AWS Proton usado para implantar e gerenciar a infraestrutura do ambiente.
+ Registre e publique um modelo de ambiente *gerenciado pelo cliente* que AWS Proton use para se conectar à sua infraestrutura provisionada existente que você gerencia. AWS Proton *não* gerencia sua infraestrutura provisionada existente.
**Importante**
Como administrador, garanta que sua infraestrutura provisionada e gerenciada e todos os parâmetros de saída sejam compatíveis com os modelos de ambiente *gerenciado pelo cliente* associados. AWS Proton não pode contabilizar as alterações em seu nome porque essas alterações não estão visíveis para AWS Proton. As inconsistências resultam em falhas.
Você pode usar o console ou o AWS CLI para registrar e publicar um modelo de ambiente.
------
#### [ Console de gerenciamento da AWS ]
**Use o console para registrar e publicar um modelo de ambiente novo.**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos de ambiente**.
1. Selecione **Criar modelo de ambiente**.
1. Na página **Criar modelo de ambiente**, na seção **Opções de modelo**, escolha uma das duas opções de modelo disponíveis.
+ **Criar um modelo para provisionar novos ambientes**.
+ **Criar um modelo para usar a infraestrutura provisionada que você gerencia**.
1. Se você escolher **Criar um modelo para provisionar novos ambientes**, na seção **Fonte do pacote de modelos**, escolha uma das três opções de origem do pacote de modelos disponíveis. Para saber mais sobre requisitos e pré-requisitos de sincronização de modelos, consulte [Configurações de sincronização de modelo](ag-template-sync-configs.md).
+ **Usar um dos nossos pacotes de modelos de amostra**.
+ **Usar seu próprio pacote de modelos**.
+ **[Sincronizar modelos do Git](ag-template-sync-configs.md)**.
1.
**Fornecer um caminho para um pacote de modelos.**
1. Se você escolheu **Usar um dos nossos pacotes de modelos de amostra**:
Na seção **Exemplo de pacote de modelos**, selecione um pacote de modelos de amostra.
1. Se você escolheu **Sincronizar modelos do Git**, na seção **Código-fonte:**
1. Selecione o repositório para sua configuração de sincronização de modelos.
1. Insira o nome da ramificação do repositório a partir da qual sincronizar.
1. (Opcional) Insira o nome de um diretório para limitar a pesquisa do seu pacote de modelos.
1. Caso contrário, na seção de **localização do pacote S3**, forneça um caminho para seu pacote de modelos.
1. Na seção **Detalhes do modelo**.
1. Insira um **nome de modelo**.
1. (Opcional) Insira um **Nome para exibição do modelo**.
1. (Opcional) Insira uma **Descrição de modelo** para o modelo de ambiente.
1. (Opcional) Marque a caixa de seleção **Personalizar configurações de criptografia (avançado)** na seção **Configurações de criptografia** para fornecer sua própria chave de criptografia.
1. (Opcional) Na seção **Tags**, escolha **Adicionar nova tag** e insira uma chave e um valor para criar uma tag gerenciada pelo cliente.
1. Escolha **Criar modelo de ambiente**.
Agora você está em uma nova página que exibe o status e os detalhes do seu novo modelo de ambiente. Esses detalhes incluem uma lista de AWS tags gerenciadas pelo cliente. AWS Proton gera automaticamente tags AWS gerenciadas para você quando você cria AWS Proton recursos. Para obter mais informações, consulte [AWS Proton recursos e marcação](resources.md).
1. O status de um novo status de modelo de ambiente começa no estado **Rascunho**. Você e outras pessoas com permissões de `proton:CreateEnvironment` podem visualizá-lo e acessá-lo. Siga a próxima etapa para disponibilizar o modelo para outras pessoas.
1. Na seção **Versões do modelo**, escolha o botão de rádio à esquerda da versão secundária do modelo que você acabou de criar (1.0). Como alternativa, você pode escolher **Publicar** no alerta de informações e pular a próxima etapa.
1. Na seção **Versões do modelo**, escolha **Publicar**.
1. O status do modelo muda para **Publicado**. Por ser a versão mais recente do modelo, é a versão **recomendada**.
1. No painel de navegação, selecione **Modelos de ambiente** para ver uma lista dos modelos e detalhes do seu ambiente.
**Use o console para registrar novas versões principais e secundárias de um modelo de ambiente.**
Para obter mais informações, consulte [Modelos versionados](ag-template-versions.md).
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos de ambiente**.
1. Na lista de modelos de ambiente, escolha o nome do modelo de ambiente para o qual você deseja criar uma versão principal ou secundária.
1. Na visualização de detalhes do modelo de ambiente, escolha **Criar nova versão** na seção **Versões do modelo**.
1. Na página **Criar uma nova versão de modelo de ambiente**, na seção **Origem do pacote de modelos**, escolha uma das duas opções de origem de pacote de modelo disponíveis.
+ **Usar um dos nossos pacotes de modelos de amostra**.
+ **Usar seu próprio pacote de modelos**.
1. Fornecer um caminho para o pacote de modelos selecionado.
+ Se você escolheu **Usar um dos nossos pacotes de modelos de amostra**, na seção **Pacote de modelos de amostra**, selecione um pacote de modelos de amostra.
+ Se você escolheu **Usar seu próprio pacote de modelos**, na seção **Localização do pacote S3**, escolha o caminho para seu pacote de modelos.
1. Na seção **Detalhes do modelo**.
1. (Opcional) Insira um **Nome para exibição do modelo**.
1. (Opcional) Insira uma **Descrição de modelo** para o modelo de serviço.
1. Na seção **Detalhes de modelo**, escolha uma das seguintes opções.
+ Para criar uma versão secundária, mantenha a caixa de seleção **Marcar para criar uma nova versão principal** vazia.
+ Para criar uma versão principal, marque a caixa de seleção **Marcar para criar uma nova versão principal**.
1. Continue com as etapas do console para criar a nova versão secundária ou principal e escolha **Criar nova versão**.
------
#### [ AWS CLI ]
**Use a CLI para registrar e publicar um novo modelo de ambiente, conforme mostrado nas etapas a seguir.**
1. Crie um modelo *padrão* de ambiente OU um *gerenciado pelo cliente* especificando a região, o nome, o nome de exibição (opcional) e a descrição (opcional).
1. Criar um modelo de ambiente *padrão*.
Execute o seguinte comando:
```
$ aws proton create-environment-template \
--name "simple-env" \
--display-name "Fargate" \
--description "VPC with public access"
```
Resposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-11T23:02:45.336000+00:00",
"description": "VPC with public access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-11T23:02:45.336000+00:00",
"name": "simple-env"
}
}
```
1. Crie um modelo de ambiente *gerenciado pelo cliente* adicionando o parâmetro `provisioning` com o valor `CUSTOMER_MANAGED`.
Execute o seguinte comando:
```
$ aws proton create-environment-template \
--name "simple-env" \
--display-name "Fargate" \
--description "VPC with public access" \
--provisioning "CUSTOMER_MANAGED"
```
Resposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-11T23:02:45.336000+00:00",
"description": "VPC with public access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-11T23:02:45.336000+00:00",
"name": "simple-env",
"provisioning": "CUSTOMER_MANAGED"
}
}
```
1.
**Crie uma versão secundária 0 da versão principal 1 do modelo de ambiente**
Essa e as etapas restantes são as mesmas para os modelos de ambiente *padrão* e *gerenciado pelo cliente*.
Inclua o nome do modelo, a versão principal e o nome e a chave do bucket do S3 para o bucket que contém seu pacote de modelos de ambiente.
Execute o seguinte comando:
```
$ aws proton create-environment-template-version \
--template-name "simple-env" \
--description "Version 1" \
--source s3="{bucket=your_s3_bucket, key=your_s3_key}"
```
Resposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:47.763000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "REGISTRATION_IN_PROGRESS",
"templateName": "simple-env"
}
}
```
1. Use o comando get para verificar o status dos cadastros.
Execute o seguinte comando:
```
$ aws proton get-environment-template-version \
--template-name "simple-env" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"environment": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:47.763000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "DRAFT",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
1. Publique a versão secundária 0 da versão principal 1 do modelo de ambiente fornecendo o nome do modelo e a versão principal e secundária. Esta versão é a versão `Recommended`.
Execute o seguinte comando:
```
$ aws proton update-environment-template-version \
--template-name "simple-env" \
--major-version "1" \
--minor-version "0" \
--status "PUBLISHED"
```
Resposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:54.610000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
Depois de criar um novo modelo usando o AWS CLI, você pode ver uma lista de AWS etiquetas gerenciadas pelo cliente. AWS Proton gera automaticamente tags AWS gerenciadas para você. Você também pode modificar e criar etiquetas gerenciadas pelo cliente usando o AWS CLI. Para obter mais informações, consulte [AWS Proton recursos e marcação](resources.md).
Execute o seguinte comando:
```
$ aws proton list-tags-for-resource \
--resource-arn "arn:aws:proton:region-id:123456789012:environment-template/simple-env"
```
------
## Registrar e publicar modelos de serviço
Ao criar uma versão de modelo de serviço, você especifica uma lista de modelos de ambiente compatíveis. Dessa forma, quando os desenvolvedores selecionam um modelo de serviço, eles têm opções para o ambiente em que implantar o serviço.
Antes de criar um serviço a partir de um modelo de serviço ou antes de publicar um modelo de serviço, confirme se os ambientes foram implantados a partir dos modelos de ambiente compatíveis listados.
Você *não pode* atualizar um serviço para a nova versão principal se ele for implantado em um ambiente criado a partir de um modelo de ambiente compatível removido.
Para adicionar ou remover modelos de ambiente compatíveis para uma versão de modelo de serviço, você cria uma nova versão principal dela.
Você pode usar o console ou o AWS CLI para registrar e publicar um modelo de serviço.
------
#### [ Console de gerenciamento da AWS ]
**Use o console para registrar e publicar um novo modelo de serviço.**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos de serviço**.
1. Selecione **Criar modelo de serviço**.
1. Na página **Criar modelo de serviço**, na seção **Origem do pacote de modelos**, escolha uma das opções de modelo disponíveis.
+ **Usar seu próprio pacote de modelos**.
+ **Sincronizar modelos do Git**.
1.
**Fornecer um caminho para um pacote de modelos.**
1. Se você escolheu **Sincronizar modelos do Git**, na seção **Repositório do código-fonte:**
1. Selecione o repositório para sua configuração de sincronização de modelos.
1. Insira o nome da ramificação do repositório a partir da qual sincronizar.
1. (Opcional) Insira o nome de um diretório para limitar a pesquisa do seu pacote de modelos.
1. Caso contrário, na seção de **localização do pacote S3**, forneça um caminho para seu pacote de modelos.
1. Na seção **Detalhes do modelo**.
1. Insira um **nome de modelo**.
1. (Opcional) Insira um **Nome para exibição do modelo**.
1. (Opcional) Insira uma **Descrição de modelo** para o modelo de serviço.
1. Na seção **Modelos de ambiente compatíveis**, escolha de uma lista de modelos de ambiente compatíveis.
1. (Opcional) Na seção **Configurações de criptografia**, escolha **Personalizar configurações de criptografia (avançado)** para fornecer sua própria chave de criptografia.
1. (Opcional) Na seção **Pipeline**:
Se você não estiver incluindo uma definição de pipeline de serviço em seu modelo de serviço, desmarque a caixa de seleção **Pipeline - opcional** na parte inferior da página. *Não é possível* alterar essa configuração após a criação do modelo de serviço. Para obter mais informações, consulte [Pacotes de modelos](ag-template-authoring.md#ag-template-bundles).
1. (Opcional) Na seção **Fontes de componentes compatíveis**, em **Fontes de componentes**, escolha **Definido diretamente** para permitir a anexação de componentes definidos diretamente às suas instâncias de serviço.
1. (Opcional) Na seção **Tags**, escolha **Adicionar nova tag** e insira uma chave e um valor para criar uma tag gerenciada pelo cliente.
1. Selecione **Criar um modelo de serviço**.
Agora você está em uma nova página que exibe o status e os detalhes do seu novo modelo de serviço. Esses detalhes incluem uma lista de AWS tags gerenciadas pelo cliente. AWS Proton gera automaticamente tags AWS gerenciadas para você quando você cria AWS Proton recursos. Para obter mais informações, consulte [AWS Proton recursos e marcação](resources.md).
1. O status de um novo status de modelo de serviço começa no estado **Rascunho**. Você e outras pessoas com permissões de `proton:CreateService` podem visualizá-lo e acessá-lo. Siga a próxima etapa para disponibilizar o modelo para outras pessoas.
1. Na seção **Versões do modelo**, escolha o botão de rádio à esquerda da versão secundária do modelo que você acabou de criar (1.0). Como alternativa, você pode escolher **Publicar** no alerta de informações e pular a próxima etapa.
1. Na seção **Versões do modelo**, escolha **Publicar**.
1. O status do modelo muda para **Publicado**. Por ser a versão mais recente do modelo, é a versão **recomendada**.
1. No painel de navegação, selecione **Modelos de serviço** para ver uma lista dos modelos e detalhes do seu serviço.
**Use o console para registrar novas versões principais e secundárias de um modelo de serviço.**
Para obter mais informações, consulte [Modelos versionados](ag-template-versions.md).
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos de serviço**.
1. Na lista de modelos de serviço, escolha o nome do modelo de serviço para o qual você deseja criar uma versão principal ou secundária.
1. Na visualização de detalhes do modelo de serviço, escolha **Criar nova versão** na seção **Versões do modelo**.
1. Na página **Criar uma nova versão do modelo de serviço**, na seção **Origem do pacote**, selecione **Usar seu próprio pacote de modelos**.
1. Na seção de **localização do pacote S3**, escolha um caminho para seu pacote de modelos.
1. Na seção **Detalhes do modelo**.
1. (Opcional) Insira um **Nome para exibição do modelo**.
1. (Opcional) Insira uma **Descrição de modelo** para o modelo de serviço.
1. Na seção **Detalhes de modelo**, escolha uma das seguintes opções.
+ Para criar uma versão secundária, mantenha a caixa de seleção **Marcar para criar uma nova versão principal** vazia.
+ Para criar uma versão principal, marque a caixa de seleção **Marcar para criar uma nova versão principal**.
1. Continue com as etapas do console para criar a nova versão secundária ou principal e escolha **Criar nova versão**.
------
#### [ AWS CLI ]
Para criar um modelo de serviço que implanta um serviço sem um pipeline de serviço, adicione o parâmetro e o valor `--pipeline-provisioning "CUSTOMER_MANAGED"` ao comando `create-service-template`. Configure seus pacotes de modelos conforme descrito em criação de [Pacotes de modelos](ag-template-authoring.md#ag-template-bundles) e [Requisitos de esquema para pacotes de modelos de serviço](ag-schema.md#schema-req-svc).
**nota**
Não é possível modificar o `pipelineProvisioning` após o modelo de serviço ser criado.
1.
**Use a CLI para registrar e publicar um novo modelo de serviço, com ou sem um pipeline de serviço, conforme mostrado nas etapas a seguir.**
1.
**Crie um modelo de serviço com um pipeline de serviço usando a CLI.**
Especifique o nome, o nome para exibição (opcional) e a descrição (opcional).
Execute o seguinte comando:
```
$ aws proton create-service-template \
--name "fargate-service" \
--display-name "Fargate" \
--description "Fargate-based Service"
```
Resposta:
```
{
"serviceTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service",
"createdAt": "2020-11-11T23:02:55.551000+00:00",
"description": "Fargate-based Service",
"displayName": "Fargate",
"lastModifiedAt": "2020-11-11T23:02:55.551000+00:00",
"name": "fargate-service"
}
}
```
1.
**Crie um modelo de serviço sem um pipeline de serviço.**
Adicionar `--pipeline-provisioning`.
Execute o seguinte comando:
```
$ aws proton create-service-template \
--name "fargate-service" \
--display-name "Fargate" \
--description "Fargate-based Service" \
--pipeline-provisioning "CUSTOMER_MANAGED"
```
Resposta:
```
{
"serviceTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service",
"createdAt": "2020-11-11T23:02:55.551000+00:00",
"description": "Fargate-based Service",
"displayName": "Fargate",
"lastModifiedAt": "2020-11-11T23:02:55.551000+00:00",
"name": "fargate-service",
"pipelineProvisioning": "CUSTOMER_MANAGED"
}
}
```
1.
**Crie uma versão secundária 0 da versão principal 1 do modelo de serviço.**
Inclua o nome do modelo, os modelos de versão compatíveis, a versão principal e o nome e a chave do bucket do S3 para o bucket que contém seu pacote de modelos de serviço.
Execute o seguinte comando:
```
$ aws proton create-service-template-version \
--template-name "fargate-service" \
--description "Version 1" \
--source s3="{bucket=your_s3_bucket, key=your_s3_key}" \
--compatible-environment-templates '[{"templateName":"simple-env","majorVersion":"1"}]'
```
Resposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "REGISTRATION_IN_PROGRESS",
"templateName": "fargate-service"
}
}
```
1. Use o comando *get* para verificar o status dos cadastros.
Execute o seguinte comando:
```
$ aws proton get-service-template-version \
--template-name "fargate-service" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:us-east-1:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"",
"status": "DRAFT",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
1. Publique o modelo de serviço usando o comando update para alterar o status para `"PUBLISHED"`.
Execute o seguinte comando:
```
$ aws proton update-service-template-version \
--template-name "fargate-service" \
--description "Version 1" \
--major-version "1" \
--minor-version "0" \
--status "PUBLISHED"
```
Resposta:
```
{
"serviceTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello pipeline\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"\n",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
1. Verifique se a versão 1.0 AWS Proton foi publicada usando o comando get para recuperar dados detalhados do modelo de serviço.
Execute o seguinte comando:
```
$ aws proton get-service-template-version \
--template-name "fargate-service" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:us-east-1:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:03:04.767000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
------
# Visualizar dados do modelo
Você pode visualizar listas de modelos com detalhes e visualizar modelos individuais com dados detalhados usando o [console do AWS Proton](https://console.aws.amazon.com//proton/) e o AWS CLI.
Os dados do modelo de ambiente *gerenciado pelo cliente* incluem o parâmetro `provisioned` com o valor `CUSTOMER_MANAGED`.
Se um modelo de serviço *não* incluir um pipeline de serviço, os dados do modelo de serviço incluirão o parâmetro `pipelineProvisioning` com o valor `CUSTOMER_MANAGED`.
Para obter mais informações, consulte [Registre e publique modelos](template-create.md).
Você pode usar o console ou o AWS CLI para listar e visualizar os dados do modelo.
------
#### [ Console de gerenciamento da AWS ]
**Use o console para listar e visualizar modelos.**
1. Para ver uma lista de modelos, escolha **modelos (Ambiente ou Serviço)**.
1. Para visualizar dados detalhados, escolha o nome de um modelo.
Visualize os dados detalhados do modelo, uma lista das versões principais e secundárias do modelo, uma lista dos AWS Proton recursos que foram implantados usando versões de modelo e tags de modelo.
A versão principal e a versão secundária recomendadas são rotuladas como **Recomendadas**.
------
#### [ AWS CLI ]
**Use o AWS CLI para listar e visualizar modelos.**
Execute o seguinte comando:
```
$ aws proton get-environment-template-version \
--template-name "simple-env" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-10T18:35:08.293000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-10T18:35:11.162000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "DRAFT",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
Execute o seguinte comando:
```
$ aws proton list-environment-templates
```
Resposta:
```
{
"templates": [
{
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env-3",
"createdAt": "2020-11-10T18:35:05.763000+00:00",
"description": "VPC with Public Access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-10T18:35:05.763000+00:00",
"name": "simple-env-3",
"recommendedVersion": "1.0"
},
{
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env-1",
"createdAt": "2020-11-10T00:14:06.881000+00:00",
"description": "Some SSM Parameters",
"displayName": "simple-env-1",
"lastModifiedAt": "2020-11-10T00:14:06.881000+00:00",
"name": "simple-env-1",
"recommendedVersion": "1.0"
}
]
}
```
Visualizar uma versão secundária de um modelo de serviço.
Execute o seguinte comando:
```
$ aws proton get-service-template-version \
--template-name "fargate-service" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:us-east-1:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"",
"status": "DRAFT",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
Visualize um modelo de serviço sem um pipeline de serviço, conforme mostrado no próximo exemplo de comando e resposta.
Execute o seguinte comando:
```
$ aws proton get-service-template \
--name "simple-svc-template-cli"
```
Resposta:
```
{
"serviceTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/simple-svc-template-cli",
"createdAt": "2021-02-18T15:38:57.949000+00:00",
"displayName": "simple-svc-template-cli",
"lastModifiedAt": "2021-02-18T15:38:57.949000+00:00",
"status": "DRAFT",
"name": "simple-svc-template-cli",
"pipelineProvisioning": "CUSTOMER_MANAGED"
}
}
```
------
# Atualizar um modelo
Você pode atualizar um modelo conforme descrito na lista a seguir.
+ Edite o `description` ou o `display name` de um modelo ao usar o console ou o AWS CLI. Você *não pode* editar o `name` de um modelo.
+ Atualize o status de uma versão secundária do modelo ao usar o console ou o AWS CLI. Você só pode alterar o status de `DRAFT` para `PUBLISHED`.
+ Edite o nome de exibição e a descrição de uma versão secundária ou principal de um modelo ao usar o AWS CLI.
------
#### [ Console de gerenciamento da AWS ]
Edite a descrição e o nome de exibição do modelo usando o console conforme descrito nas etapas a seguir.
**Na lista de modelos.**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos (Ambiente ou Serviço)**.
1. Na lista de modelos, escolha o botão de rádio à esquerda do modelo para o qual você deseja atualizar a descrição ou o nome de exibição.
1. Escolha **Ações** e então **Editar**.
1. Na página **Editar modelo (ambiente ou serviço)**, na seção **Detalhes do modelo**, insira suas edições no formulário e escolha **Salvar alterações**.
Altere o status de uma versão secundária de um modelo usando o console para publicar um modelo conforme descrito a seguir. Você só pode alterar o status de `DRAFT` para `PUBLISHED`.
**Na página de detalhes do modelo (ambiente ou serviço).**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos (Ambiente ou Serviço)**.
1. Na lista de modelos, escolha o nome do modelo cujo status de uma versão secundária você deseja atualizar de **Rascunho** para **Publicado**.
1. Na página de detalhes do modelo (ambiente ou serviço), na seção **Versões do modelo**, selecione o botão de rádio à esquerda da versão secundária que você deseja publicar.
1. Escolha **Publicar** na seção **Versões de modelo**. O status muda de **Rascunho** para **Publicado**.
------
#### [ AWS CLI ]
O exemplo de comando e resposta a seguir mostra como você pode editar a descrição de um modelo de ambiente.
Execute o comando a seguir.
```
$ aws proton update-environment-template \
--name "simple-env" \
--description "A single VPC with public access"
```
Resposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-28T22:02:10.651000+00:00",
"description": "A single VPC with public access",
"displayName": "simple-env",
"lastModifiedAt": "2020-11-29T16:11:18.956000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
Você também pode usar o AWS CLI para atualizar modelos de serviço. Consulte o [Registrar e publicar modelos de serviço](template-create.md#svc-template-v1), etapa 5 para obter um exemplo de atualização do status de uma versão secundária de um modelo de serviço.
------
# Excluir modelos
Os modelos podem ser excluídos usando o console e o AWS CLI.
Você pode excluir uma versão secundária de um modelo de ambiente se não houver ambientes implantados nessa versão.
Você pode excluir uma versão secundária de um modelo de serviço se não houver instâncias de serviço ou pipelines implantados nessa versão. Seu pipeline pode ser implantado em uma versão de modelo diferente da sua instância de serviço. Por exemplo, se sua instância de serviço for atualizada da versão 1.0 para a 1.1 e seu pipeline ainda estiver implantado para a versão 1.0, você não poderá excluir o modelo de serviço 1.0.
------
#### [ Console de gerenciamento da AWS ]
Você pode usar o console para excluir o modelo inteiro ou as versões secundárias e principais individuais de um modelo.
Use o console para excluir modelos da seguinte maneira.
**nota**
Ao excluir o modelo inteiro, você também exclui as versões principais e secundárias do modelo.
**Na lista de modelos (ambiente ou serviço).**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos (Ambiente ou Serviço)**.
1. Na lista de modelos, marque a caixa de opção à esquerda do modelo a ser excluído.
Você só pode excluir um modelo inteiro se não houver AWS Proton recursos implantados em suas versões.
1. Escolha **Ações** e, em seguida, **Excluir** para excluir o modelo inteiro.
1. Um modal pede que você confirme a ação de exclusão.
1. Siga as instruções e escolha **Sim, excluir**.
**Na página de detalhes do modelo (ambiente ou serviço).**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos (Ambiente ou Serviço)**.
1. Na lista de modelos, escolha o nome do modelo que deseja excluir por completo ou exclua versões principais ou secundárias individuais.
1.
**Para excluir o modelo inteiro.**
Você só pode excluir um modelo inteiro se não houver AWS Proton recursos implantados em suas versões.
1. Escolha **Excluir**, canto superior direito da página.
1. Um modal pede que você confirme a ação de exclusão.
1. Siga as instruções e escolha **Sim, excluir**.
1.
**Para excluir versões principais ou secundárias de um modelo.**
Você só pode excluir uma versão secundária de um modelo se não houver AWS Proton recursos implantados nessa versão.
1. Na seção **Versões do modelo**, marque a caixa de opção à esquerda da versão que você deseja excluir.
1. Escolha **Excluir** na seção **Versões de modelo**.
1. Um modal pede que você confirme a ação de exclusão.
1. Siga as instruções e escolha **Sim, excluir**.
------
#### [ AWS CLI ]
AWS CLI as operações de exclusão de modelos *não* incluem a exclusão de outras versões de um modelo. Ao usar o AWS CLI, exclua modelos com as seguintes condições.
+ Exclua um modelo inteiro se não existirem versões secundárias ou principais do modelo.
+ Exclua uma versão principal ao excluir a última versão secundária restante.
+ Exclua uma versão secundária de um modelo se não houver AWS Proton recursos implantados nessa versão.
+ Exclua a versão secundária recomendada de um modelo se nenhuma outra versão secundária do modelo existir e se não houver AWS Proton recursos implantados nessa versão.
**Os exemplos de comandos e respostas a seguir mostram como usar o AWS CLI para excluir modelos.**
Execute o seguinte comando:
```
$ aws proton delete-environment-template-version \
--template-name "simple-env" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:54.610000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
Execute o seguinte comando:
```
$ aws proton delete-environment-template \
--name "simple-env"
```
Resposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-11T23:02:45.336000+00:00",
"description": "VPC with Public Access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-12T00:23:22.339000+00:00",
"name": "simple-env",
"recommendedVersion": "1.0"
}
}
```
Execute o seguinte comando:
```
$ aws proton delete-service-template-version \
--template-name "fargate-service" \
--major-version "1" \
--minor-version "0"
```
Resposta:
```
{
"serviceTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [{"majorVersion": "1", "templateName": "simple-env"}],
"createdAt": "2020-11-28T22:07:05.798000+00:00",
"lastModifiedAt": "2020-11-28T22:19:05.368000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
------
# Configurações de sincronização de modelo
Saiba como configurar um modelo para permitir a AWS Proton sincronização a partir de pacotes de modelos localizados nos repositórios git registrados que você define. Quando um commit é enviado para o seu repositório, o AWS Proton verifica se há alterações nos pacotes de modelos do repositório. Se ele detectar uma alteração no pacote de modelos, uma nova versão secundária ou principal do modelo será criada, caso a versão ainda não exista. AWS Proton atualmente suporta GitHub, GitHub Enterprise BitBucket e.
## Enviando um commit para um pacote de modelos sincronizados
Quando você envia um commit para uma ramificação que está sendo monitorada por um de seus modelos, o AWS Proton clona seu repositório e determina quais modelos ele precisa sincronizar. Ele verifica os arquivos em seu diretório para encontrar diretórios que correspondam à convenção de `{template-name}/{major-version}/`.
Depois de AWS Proton determinar quais modelos e versões principais estão associados ao seu repositório e ramificação, ele começa a tentar sincronizar todos esses modelos em paralelo.
Durante cada sincronização com um modelo específico, AWS Proton primeiro verifica se o conteúdo do diretório do modelo mudou desde a última sincronização bem-sucedida. Se o conteúdo não mudar, AWS Proton ignora o registro de um pacote duplicado. Isso garante que uma nova versão secundária do modelo seja criada se o conteúdo do pacote de modelos mudar. Se o conteúdo do pacote de modelos for alterado, o pacote será registrado com. AWS Proton
Depois que o pacote de modelos for registrado, AWS Proton monitora o status do registro até que o registro seja concluído.
Somente uma sincronização pode ocorrer em uma determinada versão secundária e principal do modelo em um determinado momento. Todos os commits que possam ter sido enviados enquanto uma sincronização estava em andamento são agrupados em lotes. Os commits em lote são sincronizados após a conclusão da tentativa de sincronização anterior.
## Como sincronizar modelos de serviço
AWS Proton pode sincronizar modelos de ambiente e serviço do seu repositório git. Para sincronizar seus modelos de serviço, você adiciona um arquivo adicional chamado `.template-registration.yaml` a cada diretório de versão principal em seu pacote de modelos. Esse arquivo contém detalhes adicionais AWS Proton necessários ao criar uma versão do modelo de serviço para você após uma confirmação: *ambientes compatíveis* e *fontes de componentes compatíveis*.
O caminho completo do arquivo é `service-template-name/major-version/.template-registration.yaml`. Para obter mais informações, consulte [Como sincronizar modelos de serviço](create-template-sync.md#create-template-sync-service-templates).
## Considerações sobre a configuração de sincronização de modelos
Analise as seguintes considerações sobre o uso de configurações de sincronização de modelos.
+ Os repositórios não devem ter mais de 250 MB.
+ Para configurar a sincronização de modelos, primeiro vincule o repositório ao AWS Proton. Para obter mais informações, consulte [Crie um link para seu repositório](ag-create-repo.md).
+ Quando uma nova versão do modelo é criada a partir de um modelo sincronizado, ela está no estado de `DRAFT`.
+ Uma versão secundária de um modelo será criada se uma das seguintes opções for verdadeira:
+ O conteúdo do pacote de modelos é diferente do conteúdo da última versão secundária do modelo sincronizado.
+ A última versão secundária do modelo sincronizado anteriormente foi excluída.
+ A sincronização não pode ser pausada.
+ Tanto as novas versões secundárias quanto as principais são sincronizadas automaticamente.
+ Novos modelos de nível superior não podem ser criados pelas configurações de sincronização de modelos.
+ Você não pode sincronizar com um modelo de vários repositórios usando uma configuração de sincronização de modelos.
+ Não é possível usar tags em vez de ramificações.
+ Ao [criar um modelo de serviço](template-create.md#svc-template-v1), você especifica modelos de ambiente compatíveis.
+ Você pode criar um modelo de ambiente e adicioná-lo como um ambiente compatível para seu modelo de serviço no mesmo commit.
+ As sincronizações com uma única versão principal do modelo são executadas uma por vez. Durante uma sincronização, se novos commits forem detectados, eles serão agrupados em lotes e aplicados no final da sincronização ativa. As sincronizações com diferentes versões principais do modelo acontecem paralelamente.
+ Se você alterar a ramificação a partir da qual seus modelos estão sendo sincronizados, todas as sincronizações contínuas da ramificação antiga serão concluídas primeiro. Em seguida, a sincronização começa a partir da nova ramificação.
+ Se você alterar o repositório a partir do qual seus modelos são sincronizados, qualquer sincronização contínua do repositório antigo poderá falhar ou ser concluída. Depende do estágio da sincronização em que estão.
Para obter mais informações, consulte [https://docs.aws.amazon.com/proton/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/proton/latest/APIReference/Welcome.html).
**Topics**
+ [Enviando um commit para um pacote de modelos sincronizados](#ag-commits)
+ [Como sincronizar modelos de serviço](#syncing-service-templates)
+ [Considerações sobre a configuração de sincronização de modelos](#sync-considerations)
+ [Criar uma configuração de sincronização de modelos](create-template-sync.md)
+ [Exibir detalhes da configuração de sincronização do modelo](view-template-sync.md)
+ [Editar uma configuração de sincronização de modelos](update-template-sync.md)
+ [Excluir uma configuração de sincronização de modelos](delete-template-sync.md)
# Criar uma configuração de sincronização de modelos
Saiba como criar uma configuração de sincronização de modelos com AWS Proton o.
**Criar os pré-requisitos de uma configuração de sincronização de modelos:**
+ Você [vinculou um repositório](ag-create-repo.md) com o AWS Proton.
+ Um [pacote de modelos](ag-template-authoring.md#ag-template-bundles) está localizado no seu repositório.
**O link do repositório consiste no seguinte:**
+ Uma CodeConnections conexão que dá AWS Proton permissão para acessar seu repositório e assinar suas notificações.
+ Um [perfil vinculado a serviço](using-service-linked-roles.md). Ao vincular o repositório, o perfil vinculado ao serviço será criado para você.
Antes de criar sua primeira configuração de sincronização de modelos, envie um pacote de modelos para seu repositório, conforme mostrado no layout de diretório a seguir.
```
/templates/ # subdirectory (optional)
/templates/my-env-template/ # template name
/templates/my-env-template/v1/ # template version
/templates/my-env-template/v1/infrastructure/ # template bundle
/templates/my-env-template/v1/schema/
```
Depois de criar sua primeira configuração de sincronização de modelos, novas versões de modelo são criadas automaticamente quando você envia um commit que adiciona um pacote de modelos atualizado em uma nova versão (por exemplo, em `/my-env-template/v2/`).
```
/templates/ # subdirectory (optional)
/templates/my-env-template/ # template name
/templates/my-env-template/v1/ # template version
/templates/my-env-template/v1/infrastructure/ # template bundle
/templates/my-env-template/v1/schema/
/templates/my-env-template/v2/
/templates/my-env-template/v2/infrastructure/
/templates/my-env-template/v2/schema/
```
Você pode incluir novas versões do pacote de modelos para um ou mais modelos configurados para sincronização em um único commit. AWS Proton cria uma nova versão de modelo para cada nova versão do pacote de modelos que foi incluída no commit.
Depois de criar a configuração de sincronização do modelo, você ainda pode criar manualmente novas versões do modelo no console ou com o AWS CLI fazendo o upload de pacotes de modelos de um bucket do S3. A sincronização de modelos só funciona em uma direção: do seu repositório para o. AWS Proton As versões do modelo criadas manualmente *não são* sincronizadas.
Depois de definir uma configuração de sincronização de modelos, AWS Proton escuta as alterações no seu repositório. Sempre que uma alteração é enviada, ela procura por qualquer diretório que tenha o mesmo nome do seu modelo. Em seguida, ele procura dentro desse diretório por quaisquer diretórios que se pareçam com as versões principais. AWS Proton registra o pacote de modelos na versão principal do modelo correspondente. As novas versões estão sempre no estado de `DRAFT`. Você pode [publicar as novas versões](template-create.md) com o console ou AWS CLI.
Por exemplo, suponha que você tenha um modelo chamado `my-env-template` configurado para sincronizar a partir do `my-repo/templates` em uma ramificação `main` com o layout a seguir.
```
/code
/code/service.go
README.md
/templates/
/templates/my-env-template/
/templates/my-env-template/v1/
/templates/my-env-template/v1/infrastructure/
/templates/my-env-template/v1/schema/
/templates/my-env-template/v2/
/templates/my-env-template/v2/infrastructure/
/templates/my-env-template/v2/schema/
```
AWS Proton sincroniza o conteúdo de `/templates/my-env-template/v1/` para `my-env-template:1` e o conteúdo de `/templates/my-env-template/v2/` para`my-env-template:2`. Se eles ainda não existirem, ele cria essas versões principais.
AWS Proton encontrou o primeiro diretório que correspondia ao nome do modelo. Você pode limitar as AWS Proton pesquisas de diretórios especificando um `subdirectoryPath` ao criar ou editar uma configuração de sincronização de modelo. Por exemplo, é possível especificar `/production-templates/` para o `subdirectoryPath`.
Você pode criar um modelo de configuração de sincronização utilizando o console ou o CLI.
------
#### [ Console de gerenciamento da AWS ]
**Criar um modelo e um um modelo de configuração de sincronização utilizando o console.**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos de ambiente**.
1. Selecione **Criar modelo de ambiente**.
1. Na página **Criar modelo de ambiente**, na seção **Opções de modelo**, escolha **Criar um modelo para provisionar novos ambientes**.
1. Na seção **Fonte do pacote de modelos**, escolha **Sincronizar modelos do Git**.
1. Na seção **Repositório do código-fonte**:
1. Para **Repositório**, selecione o repositório vinculado que contém seu pacote de modelos.
1. Para **Ramificação**, selecione a ramificação do repositório de onde sincronizar.
1. (Opcional) Para **Diretório pacotes de modelos**, insira o nome de um diretório para analisar a pesquisa do pacote de modelo.
1. Na seção **Detalhes do modelo**.
1. Insira um **nome de modelo**.
1. (Opcional) Insira um **Nome para exibição do modelo**.
1. (Opcional) Insira uma **Descrição de modelo** para o modelo de ambiente.
1. (Opcional) Marque a caixa de seleção **Personalizar configurações de criptografia (avançado)** na seção **Configurações de criptografia** para fornecer sua própria chave de criptografia.
1. (Opcional) Na seção **Tags**, escolha **Adicionar nova tag** e insira uma chave e um valor para criar uma tag gerenciada pelo cliente.
1. Escolha **Criar modelo de ambiente**.
Agora você está em uma nova página que exibe o status e os detalhes do seu novo modelo de ambiente. Esses detalhes incluem uma lista de tags AWS gerenciadas e gerenciadas pelo cliente. AWS Proton gera automaticamente tags AWS gerenciadas para você quando você cria AWS Proton recursos. Para obter mais informações, consulte [AWS Proton recursos e marcação](resources.md).
1. Na página de detalhes do modelo, escolha a guia **Sincronizar** para ver os dados detalhados da configuração da sincronização do modelo.
1. Escolha a guia **Versões do modelo** para visualizar as versões do modelo com detalhes do status.
1. O status de um novo status de modelo de ambiente começa no estado **Rascunho**. Você e outras pessoas com permissões de `proton:CreateEnvironment` podem visualizá-lo e acessá-lo. Siga a próxima etapa para disponibilizar o modelo para outras pessoas.
1. Na seção **Versões do modelo**, escolha o botão de rádio à esquerda da versão secundária do modelo que você acabou de criar (1.0). Como alternativa, você pode escolher **Publicar** no alerta de informações e pular a próxima etapa.
1. Na seção **Versões do modelo**, escolha **Publicar**.
1. O status do modelo muda para **Publicado**. É a versão mais recente e **recomendada** do modelo.
1. No painel de navegação, selecione **Modelos de ambiente** para ver uma lista dos modelos e detalhes do seu ambiente.
O procedimento para criar um modelo de serviço e a configuração de sincronização de modelos é semelhante.
------
#### [ AWS CLI ]
**Criar um modelo e um um modelo de configuração de sincronização utilizando o AWS CLI.**
1.
**Criar um modelo. Neste exemplo, um modelo de ambiente é criado.**
Execute o comando a seguir.
```
$ aws proton create-environment-template \
--name "env-template"
```
A resposta é a que segue.
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:us-east-1:123456789012:environment-template/env-template",
"createdAt": "2021-11-07T23:32:43.045000+00:00",
"displayName": "env-template",
"lastModifiedAt": "2021-11-07T23:32:43.045000+00:00",
"name": "env-template",
"status": "DRAFT",
"templateName": "env-template"
}
}
```
1.
**Crie sua configuração de sincronização de modelos AWS CLI fornecendo o seguinte:**
+ O modelo com o qual deseja sincronizar. Depois de criar a configuração de sincronização do modelo, você ainda pode criar novas versões dele manualmente no console ou com o AWS CLI.
+ O nome do modelo.
+ O tipo de modelo.
+ O repositório vinculado do qual deseja sincronizar.
+ O provedor do repositório vinculado.
+ A ramificação em que o pacote de modelos está localizado.
+ (Opcional) O caminho para o diretório que contém o pacote de modelo. Por padrão, AWS Proton procura o primeiro diretório que corresponda ao nome do seu modelo.
Execute o comando a seguir.
```
$ aws proton create-template-sync-config \
--template-name "env-template" \
--template-type "ENVIRONMENT" \
--repository-name "myrepos/templates" \
--repository-provider "GITHUB" \
--branch "main" \
--subdirectory "env-template/"
```
A resposta é a que segue.
```
{
"templateSyncConfigDetails": {
"branch": "main",
"repositoryName": "myrepos/templates",
"repositoryProvider": "GITHUB",
"subdirectory": "templates",
"templateName": "env-template",
"templateType": "ENVIRONMENT"
}
}
```
1. **Para publicar sua versão de modelo, consulte [Registre e publique modelos](template-create.md).**
------
## Como sincronizar modelos de serviço
Os exemplos anteriores mostram como sincronizar modelos de ambiente. Os modelos de serviço são semelhantes. Para sincronizar modelos de serviço, você adiciona um arquivo adicional chamado `.template-registration.yaml` a cada diretório de versão principal em seu pacote de modelos. Esse arquivo contém detalhes adicionais AWS Proton necessários ao criar uma versão de modelo de serviço para você após uma confirmação. Ao criar explicitamente uma versão de modelo de serviço usando o AWS Proton console ou a API, você fornece esses detalhes como entradas, e esse arquivo substitui essas entradas para sincronização de modelos.
```
./templates/ # subdirectory (optional)
/templates/my-svc-template/ # service template name
/templates/my-svc-template/v1/ # service template version
/templates/my-svc-template/v1/.template-registration.yaml # service template version properties
/templates/my-svc-template/v1/instance_infrastructure/ # template bundle
/templates/my-svc-template/v1/schema/
```
O arquivo `.template-registration.yaml` contém os detalhes a seguir.
+ **Ambientes compatíveis** [obrigatório]: Ambientes baseados nesses modelos de ambiente e versões principais são compatíveis com serviços baseados nessa versão de modelo de serviço.
+ **Fontes de componentes compatíveis** [opcional]: Componentes que usam essas fontes são compatíveis com os serviços baseados nessa versão de modelo de serviço. Se não for especificado, os componentes não poderão ser anexados a esses serviços. Para obter mais informações sobre componentes, consulte [AWS Proton componentes](ag-components.md).
A sintaxe YAML do arquivo é a seguinte:
```
compatible_environments:
- env-templ-name:major-version
- ...
supported_component_sources:
- DIRECTLY_DEFINED
```
Especifique uma ou mais combinações de modelo de ambiente/versão principal. A especificação `supported_component_sources` é opcional e o único valor suportado é `DIRECTLY_DEFINED`.
**Example .template-registration.yaml**
Neste exemplo, a versão do modelo de serviço é compatível com as versões principais 1 e 2 do modelo de ambiente `my-env-template`. Também é compatível com as versões principais 1 e 3 do modelo de ambiente `another-env-template`. O arquivo não especifica o `supported_component_sources`; portanto, os componentes não podem ser anexados aos serviços com base nessa versão do modelo de serviço.
```
compatible_environments:
- my-env-template:1
- my-env-template:2
- another-env-template:1
- another-env-template:3
```
**nota**
Anteriormente, AWS Proton definiu um arquivo diferente`.compatible-envs`,, para especificar ambientes compatíveis. AWS Proton ainda suporta esse arquivo e seu formato para compatibilidade com versões anteriores. Não recomendamos mais usá-lo, porque ele não é extensível e não oferece suporte a recursos mais novos, como componentes.
# Exibir detalhes da configuração de sincronização do modelo
Visualizar dados detalhados da configuração de sincronização do modelo usando o console ou a CLI.
------
#### [ Console de gerenciamento da AWS ]
**Usar o console para visualizar detalhes da configuração de sincronização de modelo.**
1. No painel de navegação, escolha **modelos (Ambiente ou Serviço)**.
1. Para visualizar dados detalhados, escolha o nome de um modelo para o qual você criou uma configuração de sincronização de modelos.
1. Na página de detalhes para o modelo, escolha a guia **Sincronizar** para ver os dados detalhados da configuração da sincronização do modelo.
------
#### [ AWS CLI ]
**Use o AWS CLI para ver um modelo sincronizado.**
Execute o comando a seguir.
```
$ aws proton get-template-sync-config \
--template-name "svc-template" \
--template-type "SERVICE"
```
A resposta é a que segue.
```
{
"templateSyncConfigDetails": {
"branch": "main",
"repositoryProvider": "GITHUB",
"repositoryName": "myrepos/myrepo",
"subdirectory": "svc-template",
"templateName": "svc-template",
"templateType": "SERVICE"
}
}
```
**Use o AWS CLI para obter o status de sincronização do modelo.**
Para `template-version`, insira a versão principal do modelo.
Execute o comando a seguir.
```
$ aws proton get-template-sync-status \
--template-name "env-template" \
--template-type "ENVIRONMENT" \
--template-version "1"
```
------
# Editar uma configuração de sincronização de modelos
Você pode editar qualquer um dos parâmetros de configuração de sincronização do modelo, exceto `template-name` e `template-type`.
Saiba como editar um modelo de configuração de sincronização utilizando o console ou o CLI.
------
#### [ Console de gerenciamento da AWS ]
Editar uma ramificação de modelo de configuração de sincronização utilizando o console.
**Na lista de modelos.**
1. No [console do AWS Proton](https://console.aws.amazon.com//proton/), escolha **Modelos (Ambiente ou Serviço)**.
1. Na lista de modelos, escolha o nome do modelo com a configuração de sincronização de modelo que deseja editar.
1. Na página de detalhes do modelo, escolha a guia **Sincronização de modelos**.
1. Na seção **Detalhes de sincronização de modelo**, escolha **Editar**.
1. Na página **Editar**, na seção **Repositório de código-fonte**, para **Ramificação**, selecione uma ramificação e escolha **Salvar configuração**.
------
#### [ AWS CLI ]
**O exemplo de comando e resposta a seguir mostra como você pode editar uma configuração de sincronização de modelo `branch` usando a CLI.**
Execute o comando a seguir.
```
$ aws proton update-template-sync-config \
--template-name "env-template" \
--template-type "ENVIRONMENT" \
--repository-provider "GITHUB" \
--repository-name "myrepos/templates" \
--branch "fargate" \
--subdirectory "env-template"
```
A resposta é a que segue.
```
{
"templateSyncConfigDetails": {
"branch": "fargate",
"repositoryProvider": "GITHUB",
"repositoryName": "myrepos/myrepo",
"subdirectory": "templates",
"templateName": "env-template",
"templateType": "ENVIRONMENT"
}
}
```
Você também pode usar o AWS CLI para atualizar modelos de serviço sincronizados.
------
# Excluir uma configuração de sincronização de modelos
Excluir um modelo de configuração de sincronização utilizando o console ou o CLI.
------
#### [ Console de gerenciamento da AWS ]
**Excluir um modelo de configuração de sincronização utilizando o console.**
1. Na página de detalhes do modelo, escolha a guia **Sincronização**.
1. Na seção **Detalhes da sincronização**, escolha **Desconectar**.
------
#### [ AWS CLI ]
**Os exemplos de comandos e respostas a seguir mostram como usar o AWS CLI para excluir configurações de modelos sincronizados.**
Execute o comando a seguir.
```
$ aws proton delete-template-sync-config \
--template-name "env-template" \
--template-type "ENVIRONMENT"
```
A resposta é a que segue.
```
{
"templateSyncConfig": {
"templateName": "env-template",
"templateType": "ENVIRONMENT"
}
}
```
------
# Configurações de sincronização de serviços
Com a sincronização de serviços, você pode configurar e implantar seus AWS Proton serviços usando o Git. Você pode usar o service sync para gerenciar implantações e atualizações iniciais do seu AWS Proton serviço com uma configuração definida em um repositório Git. Por meio do Git, você pode usar atributos como controle de versão e pull requests para configurar, gerenciar e implantar seus serviços. O Service Sync combina AWS Proton com o Git para ajudar você a provisionar uma infraestrutura padronizada que é definida e gerenciada por meio de modelos. AWS Proton Ele gerencia as definições de serviço em seu repositório Git e reduz a troca de ferramentas. Em comparação com o uso exclusivo do Git, a padronização de modelos e a implantação AWS Proton ajudam você a gastar menos tempo gerenciando sua infraestrutura. AWS Proton também oferece maior transparência e auditabilidade para desenvolvedores e equipes de plataforma.
## AWS Proton Arquivo OPS
O `proton-ops` arquivo define onde AWS Proton encontra o arquivo de especificação usado para atualizar sua instância de serviço. Ela também define em qual ordem atualizar as instâncias de serviço e quando promover mudanças de uma instância para outra.
O arquivo do `proton-ops` suporta a sincronização de uma instância de serviço usando o arquivo de especificação, ou vários arquivos de especificação, encontrados no seu repositório vinculado. Você pode fazer isso definindo um bloco de sincronização no arquivo `proton-ops`, como no exemplo a seguir.
**Exemplo ./configuration/proton-ops.yaml:**
```
sync:
services:
frontend-svc:
alpha:
branch: dev
spec: ./frontend-svc/test/frontend-spec.yaml
beta:
branch: dev
spec: ./frontend-svc/test/frontend-spec.yaml
gamma:
branch: pre-prod
spec: ./frontend-svc/pre-prod/frontend-spec.yaml
prod-one:
branch: prod
spec: ./frontend-svc/prod/frontend-spec-second.yaml
prod-two:
branch: prod
spec: ./frontend-svc/prod/frontend-spec-second.yaml
prod-three:
branch: prod
spec: ./frontend-svc/prod/frontend-spec-second.yaml
```
No exemplo anterior, `frontend-svc` é o nome do serviço, e `alpha`, `beta`, `gamma`, `prod-one`, `prod-two`, e `prod-three` são as instâncias.
O arquivo de `spec` pode ser todas as instâncias ou um subconjunto das instâncias definidas no arquivo de `proton-ops`. No entanto, no mínimo, ele deve ter a instância definida na ramificação e a especificação a partir da qual está sincronizando. Se as instâncias não estiverem definidas no arquivo de `proton-ops`, com a ramificação e o local do arquivo de `spec` específicos, a sincronização de serviços não criará nem atualizará essas instâncias.
Os exemplos a seguir mostram a aparência dos arquivos de `spec`. Lembre-se de que o arquivo de `proton-ops` é sincronizado a partir desses arquivos de `spec`.
**Exemplo`./frontend-svc/test/frontend-spec.yaml`:**
```
proton: "ServiceSpec"
instances:
- name: "alpha"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
- name: "beta"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
```
**Exemplo`./frontend-svc/pre-prod/frontend-spec.yaml`:**
```
proton: "ServiceSpec"
instances:
- name: "gamma"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
```
**Exemplo`./frontend-svc/prod/frontend-spec-second.yaml`:**
```
proton: "ServiceSpec"
instances:
- name: "prod-one"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
- name: "prod-two"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
- name: "prod-three"
environment: "frontend-env"
spec:
port: 80
desired_count: 1
task_size: "x-small"
image: "public.ecr.aws/z9d2n7e1/nginx:1.21.0"
```
Se uma instância não sincronizar e houver um problema contínuo ao tentar sincronizá-la, chamar a API de [https://docs.aws.amazon.com//proton/latest/APIReference/API_GetServiceInstanceSyncStatus.html](https://docs.aws.amazon.com//proton/latest/APIReference/API_GetServiceInstanceSyncStatus.html) pode ajudar a resolver o problema.
**nota**
Os clientes que usam o service sync ainda estão restritos por AWS Proton limites.
**Blockers**
Ao sincronizar seu serviço usando o AWS Proton service sync, você pode atualizar sua especificação de serviço e criar e atualizar instâncias de serviço a partir do seu repositório Git. No entanto, pode haver momentos em que você precise atualizar um serviço ou instância manualmente por meio do Console de gerenciamento da AWS ou AWS CLI.
AWS Proton ajuda a evitar a substituição de quaisquer alterações manuais feitas por meio do Console de gerenciamento da AWS ou AWS CLI, como atualizar uma instância de serviço ou excluir uma instância de serviço. Para isso, o AWS Proton cria automaticamente um bloqueador de sincronização de serviços desativando a sincronização de serviços ao detectar uma alteração manual.
Para obter todos os bloqueadores associados a um serviço, você deve fazer o seguinte na ordem de cada `serviceInstance` associada ao serviço:
+ Você só deve chamar a `getServiceSyncBlockerSummary` API com o `serviceName`.
+ Chamar a API `getServiceSyncBlockerSummary` com o `serviceName` e o `serviceInstanceName`.
Ela retorna uma lista dos bloqueadores mais recentes e o status associado a eles. Se algum bloqueador estiver marcado como **ATIVO**, você deverá resolvê-lo chamando a API `UpdateServiceSyncBlocker` com `blockerId` e `resolvedReason` para cada um.
Se você atualizar ou criar manualmente uma instância de serviço, AWS Proton cria um bloqueador de sincronização de serviço na instância de serviço. AWS Proton continua sincronizando todas as outras instâncias de serviço, mas desativa a sincronização dessa instância de serviço até que o bloqueador seja resolvido. Se você excluir uma instância de serviço de um serviço, AWS Proton cria um bloqueador de sincronização de serviço no serviço. Isso AWS Proton impede a sincronização de qualquer uma das instâncias do serviço até que o bloqueador seja resolvido.
Depois de ter todos os bloqueadores ativos, você deve resolvê-los chamando a API `UpdateServiceSyncBlocker` com `blockerId` e `resolvedReason` para cada um dos bloqueadores ativos.
Usando o Console de gerenciamento da AWS, você pode determinar se uma sincronização de serviço está desativada navegando até a guia **Sincronização de serviços AWS Proton ** e escolhendo-a. Se o serviço ou as instâncias do serviço estiverem bloqueados, um botão **Habilitar** será exibido. Para habilitar a sincronização de serviços, escolha **Habilitar**.
**Topics**
+ [AWS Proton Arquivo OPS](#service-sync-ops)
+ [Criar uma configuração de sincronização de serviço](create-service-sync.md)
+ [Visualizar detalhes da configuração de uma sincronização de serviço](get-service-sync.md)
+ [Editar uma configuração de sincronização de serviço](update-service-sync.md)
+ [Excluir uma configuração de sincronização de serviço](delete-service-sync.md)
# Criar uma configuração de sincronização de serviço
Você pode criar uma configuração de sincronização de serviço usando o console ou AWS CLI.
------
#### [ Console de gerenciamento da AWS ]
1. Na página **Escolher um modelo de serviço**, selecione um modelo e escolha **Configurar**.
1. Na página **Configurar serviço**, na seção **Detalhes do serviço**, insira um novo **Nome de serviço**.
1. (Opcional) Insira uma descrição para o serviço.
1. Na seção **Repositório de código-fonte do aplicativo**, escolha **Escolha um repositório Git vinculado** para selecionar um repositório ao qual você já tenha vinculado. AWS Proton Se você ainda não tiver um repositório vinculado, escolha **Vincular outro repositório Git** e siga as instruções em [Criar um link para seu repositório](https://docs.aws.amazon.com//proton/latest/userguide/ag-create-repo.html).
1. Para **Repositório**, escolha o nome do seu repositório de códigos-fonte da lista.
1. Em **Ramificação**, escolha o nome da ramificação do repositório de código-fonte na lista.
1. (Opcional) Na seção **Tags**, escolha **Adicionar nova tag** e insira uma chave e um valor para criar uma tag gerenciada pelo cliente.
1. Escolha **Próximo**.
1. Na página **Configurar instâncias de serviço**, na seção **Fonte de definição de serviço**, selecione **Sincronizar seu serviço a partir do Git**.
1. Na seção **Arquivos de definição de serviço**, se você quiser que o AWS Proton crie seu arquivo do `proton-ops`, selecione **Quero que o AWS Proton crie os arquivos**. Com essa opção, AWS Proton cria o `proton-ops` arquivo `spec` and nos locais que você especificar. Selecione **Estou fornecendo meus próprios arquivos** para criar seu próprio arquivo OPS.
1. Na seção **Repositório de definição de serviço, escolha Escolher um repositório** **Git vinculado** para selecionar um repositório ao qual você já tenha vinculado. AWS Proton
1. Para **Nome do repositório**, escolha o nome do seu repositório de códigos-fonte da lista.
1. Para **ramificação de `proton-ops` arquivo**, escolha o nome de sua ramificação na lista onde AWS Proton colocará seu OPS e arquivo de especificação.
1. Na seção **Instâncias do serviço**, cada campo é preenchido automaticamente com base nos valores do arquivo de `proton-ops`.
1. Escolha **Avançar** e revise suas entradas.
1. Escolha **Criar**.
------
#### [ AWS CLI ]
**Crie uma configuração de sincronização de serviço usando o AWS CLI**
+ Execute o comando a seguir.
```
$ aws proton create-service-sync-config \
--resource "service-arn" \
--repository-provider "GITHUB" \
--repository "example/proton-sync-service" \
--ops-file-branch "main" \
--proton-ops-file "./configuration/custom-proton-ops.yaml" (optional)
```
A resposta é a que segue.
```
{
"serviceSyncConfig": {
"branch": "main",
"filePath": "./configuration/custom-proton-ops.yaml",
"repositoryName": "example/proton-sync-service",
"repositoryProvider": "GITHUB",
"serviceName": "service name"
}
}
```
------
# Visualizar detalhes da configuração de uma sincronização de serviço
É possível exibir os dados de detalhes de configuração para uma sincronização do serviço usando o console do ou o AWS CLI.
------
#### [ Console de gerenciamento da AWS ]
**Use o console do para visualizar detalhes da configuração de uma sincronização de serviço**
1. No painel de navegação, escolha **Serviços**.
1. Para visualizar dados detalhados, escolha o nome de um serviço para o qual você criou uma configuração de sincronização de serviços.
1. Na página de detalhes do serviço, selecione a guia **Sincronização do serviço** para ver os dados detalhados da configuração da sincronização do serviço.
------
#### [ AWS CLI ]
**Use o AWS CLI para obter um serviço sincronizado.**
Execute o comando a seguir.
```
$ aws proton get-service-sync-config \
--service-name "service name"
```
A resposta é a que segue.
```
{
"serviceSyncConfig": {
"branch": "main",
"filePath": "./configuration/custom-proton-ops.yaml",
"repositoryName": "example/proton-sync-service",
"repositoryProvider": "GITHUB",
"serviceName": "service name"
}
}
```
**Use o AWS CLI para obter o status de sincronização do serviço.**
Execute o comando a seguir.
```
$ aws proton get-service-sync-status \
--service-name "service name"
```
------
# Editar uma configuração de sincronização de serviço
Você pode editar uma configuração de sincronização de serviço usando o console ou AWS CLI.
------
#### [ Console de gerenciamento da AWS ]
Edite uma configuração de sincronização do serviço usando o console.
1. No painel de navegação, escolha **Serviços**.
1. Para visualizar dados detalhados, escolha o nome de um serviço para o qual você criou uma configuração de sincronização de serviços.
1. Na página de detalhes de serviço, escolha a guia **Sincronização de serviço**.
1. Na seção **Sincronização de serviços**, escolha **Editar**.
1. Na página **Editar**, atualize as informações que deseja editar e escolha **Salvar**.
------
#### [ AWS CLI ]
**O exemplo de comando e resposta a seguir mostra como você pode editar uma configuração de sincronização de serviço usando a AWS CLI.**
Execute o comando a seguir.
```
$ aws proton update-service-sync-config \
--service-name "service name" \
--repository-provider "GITHUB" \
--repository "example/proton-sync-service" \
--ops-file-branch "main" \
--ops-file "./configuration/custom-proton-ops.yaml"
```
A resposta é a que segue.
```
{
"serviceSyncConfig": {
"branch": "main",
"filePath": "./configuration/custom-proton-ops.yaml",
"repositoryName": "example/proton-sync-service",
"repositoryProvider": "GITHUB",
"serviceName": "service name"
}
}
```
------
# Excluir uma configuração de sincronização de serviço
Você pode excluir uma configuração de sincronização de serviço usando o console ou AWS CLI.
------
#### [ Console de gerenciamento da AWS ]
**Exclua uma configuração de sincronização do serviço usando o console**
1. Na página de detalhes de serviço, escolha a guia **Sincronização de serviço**.
1. Na seção **Detalhes da sincronização do serviço**, escolha **Desconectar** para desconectar seu repositório. Depois que seu repositório for desconectado, não sincronizaremos mais o serviço desse repositório.
------
#### [ AWS CLI ]
**Os exemplos de comandos e respostas a seguir mostram como usar o AWS CLI para excluir configurações sincronizadas do serviço.**
Execute o comando a seguir.
```
$ aws proton delete-service-sync-config \
--service-name "service name"
```
A resposta é a que segue.
```
{
"serviceSyncConfig": {
"branch": "main",
"filePath": "./configuration/custom-proton-ops.yaml",
"repositoryName": "example/proton-sync-service",
"repositoryProvider": "GITHUB",
"serviceName": "service name"
}
}
```
**nota**
A sincronização de serviços não exclui instâncias de serviço. Ele só exclui a configuração.
------