

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á.

# Use construções em loop em AWSTOE
<a name="toe-looping-constructs"></a>

Esta seção fornece informações para ajudar você a criar estruturas em loop no AWSTOE. Estruturas em loop definem uma sequência repetida de instruções. Você pode usar os seguintes tipos de estruturas em loop no AWSTOE:
+ `for` estruturas: itere sobre uma sequência limitada de inteiros.
+ `forEach` estruturas
  + `forEach` loop com lista de entrada: itera sobre uma coleção finita de strings. 
  + `forEach` loop com lista delimitada: itera sobre uma coleção finita de strings unidas por um delimitador.

**nota**  
As estruturas em loop suportam somente tipos de dados de string.

**Topics**
+ [Variáveis de iteração de referência](#toe-loop-iteration-variables)
+ [Tipos de estruturas em loop](#toe-loop-types)
+ [Campos de etapa](#toe-loop-step-fields)
+ [Saídas de etapa e iteração](#toe-loop-step-output)

## Variáveis de iteração de referência
<a name="toe-loop-iteration-variables"></a>

Para se referir ao índice e ao valor da variável de iteração atual, a expressão de referência `{{ loop.* }}` deve ser usada no corpo de entrada de uma etapa que contém uma estrutura em loop. Essa expressão não pode ser usada para se referir às variáveis de iteração da estrutura em loop de outra etapa.

A expressão de referência consiste nos seguintes membros:
+ `{{ loop.index }}`: a posição ordinal da iteração atual, indexada em `0`. 
+ `{{ loop.value }}`: o valor associado à variável de iteração atual. 

### Nomes de loop
<a name="toe-loop-iteration-variables-names"></a>

 Todas as estruturas em loop têm um campo de nome opcional para identificação. Se um nome de loop for fornecido, ele poderá ser usado para se referir às variáveis de iteração no corpo de entrada da etapa. Para se referir aos índices e valores de iteração de um loop nomeado, use `{{ <loop_name>.* }}` com `{{ loop.* }}` no corpo de entrada da etapa. Essa expressão não pode ser usada para se referir à estrutura em loop nomeada de outra etapa. 

A expressão de referência consiste nos seguintes membros:
+ `{{ <loop_name>.index }}`: a posição ordinal da iteração atual do loop nomeado, indexada em `0`.
+ `{{ <loop_name>.value }}`: o valor associado à variável de iteração atual do loop nomeado.

### Resolver expressões de referência
<a name="toe-loop-iteration-variables-expressions"></a>

 AWSTOE Resolve as expressões de referência da seguinte forma: 
+ `{{ <loop_name>.* }}`— AWSTOE resolve essa expressão usando a seguinte lógica:
  + Se o loop da etapa em execução no momento corresponder ao valor do `<loop_name>`, a expressão de referência será resolvida para a estrutura em loop da etapa em execução no momento.
  + `<loop_name>` resolve para a estrutura em loop nomeada se ela aparecer na etapa em execução no momento.
+ `{{ loop.* }}`— AWSTOE resolve a expressão usando a construção de loop definida na etapa atualmente em execução.

Se expressões de referência forem usadas em uma etapa que não contém um loop, elas AWSTOE não resolverão as expressões e elas aparecerão na etapa sem substituição. 

**nota**  
As expressões de referência devem estar entre aspas duplas para serem interpretadas corretamente pelo compilador YAML.

## Tipos de estruturas em loop
<a name="toe-loop-types"></a>

Esta seção fornece informações e exemplos sobre os tipos de estrutura em loop que podem ser usados no AWSTOE.

**Topics**
+ [loop `for`](#toe-loop-types-for)
+ [loop `forEach` com lista de entrada](#toe-loop-types-foreach)
+ [loop `forEach` com lista delimitada](#toe-loop-types-foreach-delimited)

### loop `for`
<a name="toe-loop-types-for"></a>

O loop `for` itera em um intervalo de inteiros especificado dentro de um limite delineado pelo início e pelo fim das variáveis. Os valores de iteração estão no conjunto `[start, end]` e incluem valores limite.

AWSTOE verifica os `updateBy` valores `start``end`, e para garantir que a combinação não resulte em um loop infinito.

esquema de loop `for`

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      for:
        start: int
        end: int
        updateBy: int
inputs:
  ...
```


**entrada de loop `for`**  

| Campo | Description | Tipo | Obrigatório | Padrão | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome exclusivo do loop. Ele deve ser exclusivo em comparação com outros nomes de loop na mesma fase. |  String  |  Não  |  ""  | 
|  `start`  | Valor inicial da iteração. Não aceita expressões de encadeamento.  |  Inteiro  |  Sim  |  n/a  | 
| `end` | Valor final da iteração. Não aceita expressões de encadeamento.  | Inteiro | Sim | n/a | 
| `updateBy` | Diferença pela qual um valor iterativo é atualizado por meio da adição. Deve ser um valor negativo ou positivo diferente de zero. Não aceita expressões de encadeamento.  | Inteiro | Sim | n/a | 

exemplo de entrada de loop `for`

```
  - name: "CalculateFileUploadLatencies"
    action: "ExecutePowerShell"
    loop:
      for:
        start: 100000
        end: 1000000
        updateBy: 100000
    inputs:
      commands:
        - |
          $f = new-object System.IO.FileStream c:\temp\test{{ loop.index }}.txt, Create, ReadWrite
          $f.SetLength({{ loop.value }}MB)
          $f.Close()
        - c:\users\administrator\downloads\latencyTest.exe --file c:\temp\test{{ loop.index }}.txt
        - AWS s3 cp c:\users\administrator\downloads\latencyMetrics.json s3://bucket/latencyMetrics.json
        - |
          Remove-Item -Path c:\temp\test{{ loop.index }}.txt
          Remove-Item -Path c:\users\administrator\downloads\latencyMetrics.json
```

### loop `forEach` com lista de entrada
<a name="toe-loop-types-foreach"></a>

O loop `forEach` itera em uma lista explícita de valores, que podem ser cadeias de caracteres e expressões encadeadas. 

loop `forEach` com esquema de lista de entrada

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        - "string"
    inputs:
  ...
```


**loop `forEach` com entrada de lista de entrada**  

| Campo | Description | Tipo | Obrigatório | Padrão | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome exclusivo do loop. Ele deve ser exclusivo em comparação com outros nomes de loop na mesma fase. |  String  |  Não  |  ""  | 
|  Lista de string de loop `forEach`  |  Lista de strings para iteração. Aceita expressões encadeadas como cadeias de strings na lista. As expressões encadeadas devem estar entre aspas duplas para serem interpretadas corretamente pelo compilador YAML.  |  Lista de strings  |  Sim  |  n/a  | 

loop `forEach` com lista de entrada (exemplo 1)

```
  - name: "ExecuteCustomScripts"
    action: "ExecuteBash"
    loop:
      name: BatchExecLoop
      forEach:
        - /tmp/script1.sh
        - /tmp/script2.sh
        - /tmp/script3.sh
    inputs:
      commands:
        - echo "Count {{ BatchExecLoop.index }}"
        - sh "{{ loop.value }}"
        - |
          retVal=$?
          if [ $retVal -ne 0 ]; then
            echo "Failed"
          else
            echo "Passed"
         fi
```

loop `forEach` com lista de entrada (exemplo 2)

```
  - name: "RunMSIWithDifferentArgs"
    action: "ExecuteBinary"
    loop:
      name: MultiArgLoop
      forEach:
        - "ARG1=C:\Users ARG2=1"
        - "ARG1=C:\Users"
        - "ARG1=C:\Users ARG3=C:\Users\Administrator\Documents\f1.txt"
    inputs:
      commands:
        path: "c:\users\administrator\downloads\runner.exe"
        args:
          - "{{ MultiArgLoop.value }}"
```

loop `forEach` com lista de entrada (exemplo 3)

```
  - name: "DownloadAllBinaries"
    action: "S3Download"
    loop:
      name: MultiArgLoop
      forEach:
        - "bin1.exe"
        - "bin10.exe"
        - "bin5.exe"
    inputs:
      - source: "s3://bucket/{{ loop.value }}"
        destination: "c:\temp\{{ loop.value }}"
```

### loop `forEach` com lista delimitada
<a name="toe-loop-types-foreach-delimited"></a>

O loop itera sobre uma string contendo valores separados por um delimitador. Para iterar sobre os constituintes da string, AWSTOE usa o delimitador para dividir a string em uma matriz adequada para iteração. 

loop `forEach` com esquema de lista delimitada

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        list: "string"
        delimiter: ".,;:\n\t -_"
    inputs:
  ...
```


**loop `forEach` com entrada de lista delimitada**  

| Campo | Description | Tipo | Obrigatório | Padrão | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome exclusivo dado ao loop. Deve ser exclusivo quando comparado com outros nomes de loop na mesma fase. |  String  |  Não  |  ""  | 
|  `list`  | Uma string composta por strings constituintes unidas por um caractere delimitador comum. Também aceita expressões encadeadas. No caso de expressões encadeadas, certifique-se de que elas estejam entre aspas duplas para uma interpretação correta pelo compilador YAML. | String |  Sim  |  n/a  | 
| `delimiter` | Caractere usado para separar as strings dentro de um bloco. O padrão é o caractere de vírgula. Somente um caractere delimitador é permitido na lista fornecida: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/imagebuilder/latest/userguide/toe-looping-constructs.html) Expressões encadeadas não podem ser usadas. | String | Não | Vírgula: "," | 

**nota**  
O valor de `list` é tratado como uma string imutável. Se a fonte de `list` for alterada durante o runtime, ela não será refletida durante a execução.

loop `forEach` com lista delimitada (exemplo 1)

Este exemplo usa o seguinte padrão de expressão de encadeamento para se referir à saída de outra etapa: `<phase_name>.<step_name>.[inputs | outputs].<var_name>`.

```
  - name: "RunMSIs"
    action: "ExecuteBinary"
    loop:
      forEach:
        list: "{{ build.GetAllMSIPathsForInstallation.outputs.stdout }}"
        delimiter: "\n"
    inputs:
      commands:
        path: "{{ loop.value }}"
```

loop `forEach` com lista delimitada (exemplo 2)

```
  - name: "UploadMetricFiles"
    action: "S3Upload"
    loop:
      forEach:
        list: "/tmp/m1.txt,/tmp/m2.txt,/tmp/m3.txt,..."
    inputs:
      commands:
        - source: "{{ loop.value }}"
          destination: "s3://bucket/key/{{ loop.value }}"
```

## Campos de etapa
<a name="toe-loop-step-fields"></a>

Os loops fazem parte de uma etapa. Qualquer campo relacionado à execução de uma etapa não é aplicado a iterações individuais. Os campos de etapa se aplicam somente no nível da etapa, da seguinte forma:
+ *TimeoutSeconds*: todas as iterações do loop devem ser executadas dentro do período especificado por esse campo. Se a execução do loop atingir o tempo limite, AWSTOE execute a política de repetição da etapa e redefina o parâmetro de tempo limite para cada nova tentativa. Se a execução do loop exceder o valor do tempo limite após atingir o número máximo de novas tentativas, a mensagem de falha da etapa indicará que a execução do loop atingiu o tempo limite. 
+ *onFailure*: o tratamento de falhas é aplicado à etapa da seguinte forma:
  + Se *OnFailure* estiver definido como`Abort`, AWSTOE sai do loop e repete a etapa de acordo com a política de repetição. Após o número máximo de tentativas de repetição, AWSTOE marca a etapa atual como falhada e interrompe a execução do processo.

    AWSTOE define o código de status da fase principal e do documento como`Failed`.
**nota**  
Nenhuma outra etapa é executada após a etapa malsucedida.
  + Se *onFailure* estiver definido como `Continue`, AWSTOE sai do loop e repete a etapa de acordo com a política de repetição. Após o número máximo de tentativas de repetição, AWSTOE marca a etapa atual como falhada e continua executando a próxima etapa.

    AWSTOE define o código de status da fase principal e do documento como`Failed`.
  + Se *onFailure* estiver definido como `Ignore`, AWSTOE sai do loop e repete a etapa de acordo com a política de repetição. Após o número máximo de tentativas de repetição, AWSTOE marca a etapa atual como `IgnoredFailure` e continua executando a próxima etapa.

    AWSTOE define o código de status da fase principal e do documento como`SuccessWithIgnoredFailure`.
**nota**  
Isso ainda é considerado uma execução bem-sucedida, mas inclui informações para que você saiba que uma ou mais etapas falharam e foram ignoradas.
+ *maxAttempts*: para cada nova tentativa, toda a etapa e todas as iterações são executadas desde o início.
+ *status*: o status geral da execução de uma etapa. `status` não representa o status de iterações individuais. O status de uma etapa com loops é determinado da seguinte forma:
  + Se uma única iteração falhar na execução, o status de uma etapa aponta para uma falha.
  + Se todas as iterações forem bem-sucedidas, o status de uma etapa indicará um sucesso.
+ *startTime*: a hora geral de início da execução de uma etapa. Não representa a hora de início das iterações individuais.
+ *endTime*: a hora geral de término da execução de uma etapa. Não representa a hora de término das iterações individuais.
+ *failureMessage*: inclui os índices de iteração que falharam em caso de erros sem tempo limite. Em caso de erros de tempo limite, a mensagem indica que a execução do loop falhou. Mensagens de erro individuais para cada iteração não são fornecidas para minimizar o tamanho das mensagens de falha.

## Saídas de etapa e iteração
<a name="toe-loop-step-output"></a>

Cada iteração contém uma saída. No final de uma execução de loop, AWSTOE consolida todas as saídas de iteração bem-sucedidas em. `detailedOutput.json` As saídas consolidadas são um agrupamento de valores que pertencem às chaves de saída correspondentes, conforme definido no esquema de saída do módulo de ação. O exemplo a seguir mostra como as saídas são consolidadas:

**Saída de `ExecuteBash` para a Iteração 1**

```
{
	"stdout":"Hello"
}
```

**Saída de `ExecuteBash` para a Iteração 2**

```
{
	"stdout":"World"
}
```

**Saída de `ExecuteBash` para a Etapa**

```
{
	"stdout":"Hello\nWorld"
}
```

Por exemplo, `ExecuteBash`, `ExecutePowerShell` e `ExecuteBinary` são módulos de ação que retornam `STDOUT` como saída do módulo de ação. As mensagens `STDOUT` são unidas ao novo caractere de linha para produzir a saída geral da etapa em `detailedOutput.json`.

AWSTOE não consolidará os resultados de iterações malsucedidas.