A versão 5 (V5) do Ferramentas da AWS para PowerShell foi lançada\$1

Para obter informações sobre mudanças significativas e migrar seus aplicativos, consulte o [tópico de migração](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html).

 [https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.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 Serviços de chamadas no Ferramentas da AWS para PowerShell
<a name="pstools-using"></a>

Esta seção fornece exemplos de uso do Ferramentas da AWS para PowerShell para acessar AWS serviços. Esses exemplos ajudam a demonstrar como usar os cmdlets para realizar tarefas reais AWS . Esses exemplos se baseiam nos cmdlets fornecidos pelo Tools for PowerShell . Para ver quais cmdlets estão disponíveis, consulte a [Referência do cmdlet do Ferramentas da AWS para PowerShell](https://docs.aws.amazon.com/powershell/v5/reference/).

Você pode encontrar mais Ferramentas da AWS para PowerShell exemplos no [Exemplos de código](powershell_code_examples.md) capítulo.

## PowerShell Codificação de concatenação de arquivos
<a name="powershell-file-concatenation-encoding"></a>

Alguns cmdlets na Ferramentas da AWS para PowerShell edição de arquivos ou registros existentes que você tem em. AWS Um exemplo é`Edit-R53ResourceRecordSet`, que chama a [ChangeResourceRecordSets](https://docs.aws.amazon.com/Route53/latest/APIReference/API_ChangeResourceRecordSets.html)API para o Amazon Route 53.

Quando você edita ou concatena arquivos em versões PowerShell 5.1 ou anteriores, PowerShell codifica a saída em UTF-16, não em UTF-8. Isso pode adicionar caracteres indesejados e criar resultados que não são válidos. Um editor hexadecimal pode revelar os caracteres indesejados.

Para evitar a conversão da saída do arquivo em UTF-16, você pode canalizar seu comando para PowerShell o `Out-File` cmdlet e especificar a codificação UTF-8, conforme mostrado no exemplo a seguir:

```
PS > *some file concatenation command* | Out-File filename.txt -Encoding utf8
```

Se você estiver executando AWS CLI comandos de dentro do PowerShell console, o mesmo comportamento se aplica. Você pode canalizar a saída de um AWS CLI comando para `Out-File` o PowerShell console. Outros cmdlets, como o `Export-Csv` ou o `Export-Clixml`, também têm um parâmetro `Encoding`. Para obter uma lista completa de cmdlets que tenham um parâmetro `Encoding` e que permitam que você corrija a codificação da saída de um arquivo concatenado, execute o comando a seguir:

```
PS > Get-Command -ParameterName "Encoding"
```

**nota**  
PowerShell 6.0 e versões mais recentes, incluindo o PowerShell Core, retêm automaticamente a codificação UTF-8 para a saída de arquivos concatenados.

## Objetos devolvidos para as PowerShell ferramentas
<a name="returned-objects-for-the-powershell-tools"></a>

Para ser Ferramentas da AWS para PowerShell mais útil em um PowerShell ambiente nativo, o objeto retornado por um Ferramentas da AWS para PowerShell cmdlet é um objeto.NET, não o objeto de texto JSON que normalmente é retornado da API correspondente no SDK. AWS Por exemplo, `Get-S3Bucket` emite uma coleção `Buckets`, não um objeto de resposta JSON do Amazon S3. A `Buckets` coleção pode ser colocada no PowerShell pipeline e interagida de maneira apropriada. Da mesma forma, `Get-EC2Instance` emite uma coleção de objetos .NET `Reservation`, não um objeto de resultado JSON `DescribeEC2Instances`. Esse comportamento é intencional e permite que a Ferramentas da AWS para PowerShell experiência seja mais consistente com a idiomática PowerShell.

As respostas do serviço real estão disponíveis se você precisar delas. Elas são armazenadas como propriedades `note` nos objetos retornados. Para ações de API que ofereçam suporte à paginação usando campos `NextToken`, eles também são anexados como propriedades `note`.

## [Amazon EC2](pstools-ec2.md)
<a name="using-ec2"></a>

Esta seção aborda as etapas necessárias para executar uma instância do Amazon EC2, incluindo como:
+ Recupere uma lista de Amazon Machine Images (AMIs).
+ Criar um par de chaves para autenticação SSH.
+ Crie e configure um grupo de segurança do Amazon EC2.
+ Executar a instância e recuperar informações sobre ela.

## [Amazon S3](pstools-s3.md)
<a name="using-s3"></a>

A seção aborda as etapas necessárias para criar um site estático hospedado no Amazon S3. Ela demonstra como:
+ Criar e excluir buckets do Amazon S3.
+ Fazer upload de arquivos para um bucket do Amazon S3 na forma de objetos.
+ Excluir objetos de um bucket do Amazon S3.
+ Designar um bucket do Amazon S3 como um site.

## [AWS Lambda and Ferramentas da AWS para PowerShell](pstools-lambda.md)
<a name="using-lambda"></a>

Esta seção fornece uma breve visão geral das Ferramentas AWS Lambda para o PowerShell módulo e descreve as etapas necessárias para configurar o módulo.

## [Amazon SNS e Amazon SQS](pstools-sqs-queue-sns-topic.md)
<a name="using-sns"></a>

Esta seção aborda as etapas necessárias para inscrever uma fila do Amazon SQS em um tópico do Amazon SNS. Ela demonstra como:
+ Crie um tópico do Amazon SNS.
+ Como criar uma fila do Amazon SQS.
+ Inscrever a fila no tópico do .
+ Envie uma mensagem para o tópico.
+ Receba a mensagem da fila.

## [CloudWatch](pstools-cw.md)
<a name="using-cw"></a>

Esta seção fornece um exemplo de como publicar dados personalizados para o CloudWatch.
+ Publique uma métrica personalizada em seu CloudWatch painel.

## Consulte também
<a name="see-also"></a>
+  [Configurando e usando o Ferramentas da AWS para PowerShell](pstools-getting-started.md) 

## Tópicos
<a name="w2aac13c23"></a>
+ [Amazon S3 e ferramentas para Windows PowerShell](pstools-s3.md)
+ [Amazon EC2 e ferramentas para Windows PowerShell](pstools-ec2.md)
+ [AWS Lambda and Ferramentas da AWS para PowerShell](pstools-lambda.md)
+ [Amazon SQS, Amazon SNS e ferramentas para Windows PowerShell](pstools-sqs-queue-sns-topic.md)
+ [CloudWatch do AWS Tools for Windows PowerShell](pstools-cw.md)
+ [Usando o ClientConfig parâmetro em cmdlets](pstools-clientconfig.md)

# Amazon S3 e ferramentas para Windows PowerShell
<a name="pstools-s3"></a>

Nesta seção, criamos um site estático AWS Tools for Windows PowerShell usando o Amazon S3 e. CloudFront No processo, demonstramos uma série de tarefas comuns com esses serviços. Essa demonstração é modelada com base no Guia de conceitos básicos para [Hospedar um site estático](https://aws.amazon.com/getting-started/projects/host-static-website/), que descreve um processo semelhante usando o [Console de gerenciamento da AWS](https://console.aws.amazon.com/s3/home).

Os comandos mostrados aqui pressupõem que você definiu credenciais padrão e uma região padrão para sua PowerShell sessão. Portanto, credenciais e regiões não estão incluídas na chamada dos cmdlets.

**nota**  
Atualmente, não há uma API do Amazon S3 para renomear um bucket ou objeto e, portanto, não há um único PowerShell cmdlet do Tools for Windows para executar essa tarefa. Para renomear um objeto no S3, recomendamos que você copie o objeto para um com um novo nome executando o [Copy-S3Object](https://docs.aws.amazon.com/powershell/v5/reference/items/Copy-S3Object.html)cmdlet e, em seguida, exclua o objeto original executando o cmdlet. [Remove-S3Object](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-S3Object.html)

**Consulte também**
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [Hospedagem de um site estático no Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html) 
+  [Console do Amazon S3](https://console.aws.amazon.com/s3/home) 

**Topics**
+ [Criar um bucket do Amazon S3, verificar sua região e, opcionalmente, removê-lo](pstools-s3-bucket-create.md)
+ [Configurar um bucket do Amazon S3 como um site e ativar o registro em log](pstools-s3-create-website.md)
+ [Fazer upload de objetos para um bucket do Amazon S3](pstools-s3-upload-object.md)
+ [Excluir objetos e buckets do Amazon S3](pstools-s3-delete-website.md)
+ [Upload de conteúdo de texto em linha para o Amazon S3](pstools-s3-upload-in-line-text.md)

# Criar um bucket do Amazon S3, verificar sua região e, opcionalmente, removê-lo
<a name="pstools-s3-bucket-create"></a>

Use o cmdlet `New-S3Bucket` para criar um novo bucket do Amazon S3. Os exemplos a seguir criam um bucket chamado `website-example`. O nome do bucket deve ser globalmente exclusivo em todas as regiões. O exemplo cria o bucket na região `us-west-1`.

```
PS > New-S3Bucket -BucketName website-example -Region us-west-2

CreationDate         BucketName
------------         ----------
8/16/19 8:45:38 PM   website-example
```

Você pode verificar a região em que o bucket está localizado usando o cmdlet `Get-S3BucketLocation`.

```
PS > Get-S3BucketLocation -BucketName website-example

Value
-----
us-west-2
```

Quando terminar este tutorial, você poderá usar a linha a seguir para remover esse bucket. Sugerimos que você deixe esse bucket no lugar, pois o usaremos em exemplos subsequentes.

```
PS > Remove-S3Bucket -BucketName website-example
```

Observe que o processo de remoção do bucket leva algum tempo para ser concluído. Se você tentar recriar um bucket com o mesmo nome imediatamente, poderá haver falha no cmdlet `New-S3Bucket` até que o antigo tenha sido removido completamente.

## Consulte também
<a name="pstools-seealso-s3-bucket-create"></a>
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [Put bucket (Referência de serviços do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUT.html) 
+  [AWS PowerShell Regiões do Amazon S3](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) 

# Configurar um bucket do Amazon S3 como um site e ativar o registro em log
<a name="pstools-s3-create-website"></a>

Use o cmdlet `Write-S3BucketWebsite` para configurar um bucket do Amazon S3 como um site estático. O exemplo a seguir especifica um nome `index.html` para a página da web de conteúdo padrão e um nome `error.html` para a página da web de erro padrão. Observe que esse cmdlet não cria essas páginas. Elas precisam ser [carregadas como objetos do Amazon S3](pstools-s3-upload-object.md).

```
PS > Write-S3BucketWebsite -BucketName website-example -WebsiteConfiguration_IndexDocumentSuffix index.html -WebsiteConfiguration_ErrorDocument error.html
RequestId      : A1813E27995FFDDD
AmazonId2      : T7hlDOeLqA5Q2XfTe8j2q3SLoP3/5XwhUU3RyJBGHU/LnC+CIWLeGgP0MY24xAlI
ResponseStream :
Headers        : {x-amz-id-2, x-amz-request-id, Content-Length, Date...}
Metadata       : {}
ResponseXml    :
```

## Consulte também
<a name="pstools-seealso-s3-create-website"></a>
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [Site Put bucket (Referência de APIs do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html) 
+  [ACL Put bucket (Referência de APIs do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) 

# Fazer upload de objetos para um bucket do Amazon S3
<a name="pstools-s3-upload-object"></a>

Use o cmdlet `Write-S3Object` para fazer upload de arquivos do seu sistema de arquivos local para um bucket do Amazon S3 como objetos. O exemplo a seguir cria e carrega dois arquivos HTML simples para um bucket do Amazon S3 e verifica a existência dos objetos carregados. O parâmetro `-File` para `Write-S3Object` especifica o nome do arquivo no sistema de arquivos local. O parâmetro `-Key` especifica o nome que o objeto correspondente terá no Amazon S3.

A Amazon deduz o tipo de conteúdo dos objetos a partir das extensões de arquivos, nesse caso, ".html".

```
PS > # Create the two files using here-strings and the Set-Content cmdlet
PS > $index_html = @"
>> <html>
>>   <body>
>>     <p>
>>       Hello, World!
>>     </p>
>>   </body>
>> </html>
>> "@
>>
PS > $index_html | Set-Content index.html
PS > $error_html = @"
>> <html>
>>   <body>
>>     <p>
>>       This is an error page.
>>     </p>
>>   </body>
>> </html>
>> "@
>>
>>$error_html | Set-Content error.html
>># Upload the files to Amazon S3 using a foreach loop
>>foreach ($f in "index.html", "error.html") {
>> Write-S3Object -BucketName website-example -File $f -Key $f -CannedACLName public-read
>> }
>>
PS > # Verify that the files were uploaded
PS > Get-S3BucketWebsite -BucketName website-example

IndexDocumentSuffix                                         ErrorDocument
-------------------                                         -------------
index.html                                                  error.html
```

 *Opções pré-configuradas de ACL* 

Os valores para especificar enlatados ACLs com o Tools for Windows PowerShell são os mesmos usados pelo. AWS SDK para .NET Observe, no entanto, que eles são diferentes dos valores usados pela ação `Put Object` do Amazon S3. O Tools for Windows PowerShell oferece suporte ao seguinte pacote: ACLs
+ NoACL
+ privado
+ public-read
+ public-read-write
+ aws-exec-read
+ authenticated-read
+ bucket-owner-read
+ bucket-owner-full-control
+ log-delivery-write

Para obter mais informações sobre essas configurações de ACL pré-configurada, consulte [Visão geral da lista de controle de acesso](https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl).

## Observação sobre multipart upload
<a name="note-regarding-multipart-upload"></a>

Se você usar a API do Amazon S3 para fazer upload de um arquivo com mais de 5 GB, será necessário utilizar o carregamento fracionado. No entanto, o `Write-S3Object` cmdlet fornecido pelo Tools for Windows PowerShell pode lidar de forma transparente com uploads de arquivos maiores que 5 GB.

### Testar o site
<a name="pstools-amazon-s3-test-website"></a>

Nesse ponto, você pode testar o site navegando até ele usando um navegador. URLs para sites estáticos hospedados no Amazon S3, siga um formato padrão.

```
http://<bucket-name>.s3-website-<region>.amazonaws.com
```

Por exemplo:

```
http://website-example.s3-website-us-west-1.amazonaws.com
```

### Consulte também
<a name="pstools-seealso-amazon-s3-test-website"></a>
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [Objeto Put (Referência de APIs do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html) 
+  [Enlatado ACLs (referência de API do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/dev/ACLOverview.html#CannedACL) 

# Excluir objetos e buckets do Amazon S3
<a name="pstools-s3-delete-website"></a>

Esta seção descreve como excluir o site que você criou nas seções anteriores. Você pode simplesmente excluir os objetos para os arquivos HTML e, em seguida, excluir o bucket do Amazon S3 para o site.

Primeiramente, execute o cmdlet `Remove-S3Object` para excluir os objetos dos arquivos HTML do bucket do Amazon S3.

```
PS > foreach ( $obj in "index.html", "error.html" ) {
>> Remove-S3Object -BucketName website-example -Key $obj
>> }
>> 
IsDeleteMarker
--------------
False
```

A resposta `False` é um artefato esperado da forma como o Amazon S3 processa a solicitação. Neste contexto, ela não indica um problema.

Agora, é possível executar o cmdlet `Remove-S3Bucket` para excluir o bucket do Amazon S3 vazio do site.

```
PS > Remove-S3Bucket -BucketName website-example

RequestId      : E480ED92A2EC703D
AmazonId2      : k6tqaqC1nMkoeYwbuJXUx1/UDa49BJd6dfLN0Ls1mWYNPHjbc8/Nyvm6AGbWcc2P
ResponseStream :
Headers        : {x-amz-id-2, x-amz-request-id, Date, Server}
Metadata       : {}
ResponseXml    :
```

Nas versões 1.1 e mais recentes do Ferramentas da AWS para PowerShell, você pode adicionar o `-DeleteBucketContent` parâmetro a`Remove-S3Bucket`, que primeiro exclui todos os objetos e versões de objetos no bucket especificado antes de tentar remover o próprio bucket. Dependendo do número de objetos ou versões de objetos no bucket, essa operação pode demorar um intervalo substancial de tempo. Nas versões do Tools for Windows PowerShell anteriores à 1.1, o bucket precisava estar vazio para `Remove-S3Bucket` poder excluí-lo.

**nota**  
A menos que você adicione o `-Force` parâmetro, Ferramentas da AWS para PowerShell solicita a confirmação antes da execução do cmdlet.

## Consulte também
<a name="pstools-seealso-amazon-s3-delete-website"></a>
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [Excluir objeto (Referência de APIs do Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectDELETE.html) 
+  [DeleteBucket (Referência da API Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETE.html) 

# Upload de conteúdo de texto em linha para o Amazon S3
<a name="pstools-s3-upload-in-line-text"></a>

O cmdlet `Write-S3Object` oferece suporte à capacidade de fazer upload de conteúdo de texto em linha para o Amazon S3. Usando o parâmetro `-Content` (alias `-Text`), você pode especificar o conteúdo baseado em texto que deve ser carregados para o Amazon S3 sem a necessidade de colocá-lo em um arquivo primeiro. O parâmetro aceita sequências de uma linha simples, bem como strings que contêm várias linhas.

```
PS > # Specifying content in-line, single line text:
PS > write-s3object amzn-s3-demo-bucket -key myobject.txt -content "file content"

PS > # Specifying content in-line, multi-line text: (note final newline needed to end in-line here-string)
PS > write-s3object amzn-s3-demo-bucket -key myobject.txt -content @"
>> line 1
>> line 2
>> line 3
>> "@
>> 
PS > # Specifying content from a variable: (note final newline needed to end in-line here-string)
PS > $x = @"
>> line 1
>> line 2
>> line 3
>> "@
>> 
PS > write-s3object amzn-s3-demo-bucket -key myobject.txt -content $x
```

# Amazon EC2 e ferramentas para Windows PowerShell
<a name="pstools-ec2"></a>

Você pode realizar tarefas comuns relacionadas à Amazon EC2 usando Ferramentas da AWS para PowerShell o.

Os comandos de exemplo mostrados aqui pressupõem que você definiu credenciais padrão e uma região padrão para sua PowerShell sessão. Portanto, não incluímos credenciais nem região quando chamamos o cmdlets. Para obter mais informações, consulte [Autenticando com AWS](creds-idc.md) e [AWS Região](pstools-installing-specifying-region.md).

**Topics**
+ [Criar um par de chaves](pstools-ec2-keypairs.md)
+ [Criar um grupo de segurança](pstools-ec2-sg.md)
+ [Encontrar uma AMI](pstools-ec2-get-amis.md)
+ [Iniciar uma instância do](pstools-ec2-launch.md)

# Criação de um par de chaves
<a name="pstools-ec2-keypairs"></a>

O `New-EC2KeyPair` exemplo a seguir cria um par de chaves e armazena na PowerShell variável `$myPSKeyPair` 

```
PS > $myPSKeyPair = New-EC2KeyPair -KeyName myPSKeyPair
```

Insira o objeto do par de chaves no cmdlet `Get-Member` para visualizar a estrutura do objeto.

```
PS > $myPSKeyPair | Get-Member

     TypeName: Amazon.EC2.Model.KeyPair

  Name                MemberType   Definition
  ----                ----------   ----------
  Equals              Method       bool Equals(System.Object obj)
  GetHashCode         Method       int GetHashCode()
  GetType             Method       type GetType()
  ToString            Method       string ToString()
  KeyFingerprint      Property     System.String KeyFingerprint {get;set;}
  KeyMaterial         Property     System.String KeyMaterial {get;set;}
  KeyName             Property     System.String KeyName {get;set;}
```

Insira o objeto do par de chaves no cmdlet `Format-List` para visualizar os valores dos membros `KeyName`, `KeyFingerprint` e `KeyMaterial`. (A saída foi truncada para facilitar a leitura.)

```
PS > $myPSKeyPair | Format-List KeyName, KeyFingerprint, KeyMaterial

  KeyName        : myPSKeyPair
  KeyFingerprint : 09:06:70:8e:26:b6:e7:ef:8f:fe:4a:1d:bc:9c:6a:63:11:ac:ad:3c
  KeyMaterial    : ----BEGIN RSA PRIVATE KEY----
                   MIIEogIBAAKCAQEAkK+ANYUS9c7niNjYfaCn6KYj/D0I6djnFoQE...
                   Mz6btoxPcE7EMeH1wySUp8nouAS9xbl9l7+VkD74bN9KmNcPa/Mu...
                   Zyn4vVe0Q5il/MpkrRogHqOB0rigeTeV5Yc3lvO0RFFPu0Kz4kcm...
                   w3Jg8dKsWn0plOpX7V3sRC02KgJIbejQUvBFGi5OQK9bm4tXBIeC...
                   daxKIAQMtDUdmBDrhR1/YMv8itFe5DiLLbq7Ga+FDcS85NstBa3h...
                   iuskGkcvgWkcFQkLmRHRoDpPb+OdFsZtjHZDpMVFmA9tT8EdbkEF...
                   3SrNeqZPsxJJIxOodb3CxLJpg75JU5kyWnb0+sDNVHoJiZCULCr0...
                   GGlLfEgB95KjGIk7zEv2Q7K6s+DHclrDeMZWa7KFNRZuCuX7jssC...
                   xO98abxMr3o3TNU6p1ZYRJEQ0oJr0W+kc+/8SWb8NIwfLtwhmJEy...
                   1BX9X8WFX/A8VLHrT1elrKmLkNECgYEAwltkV1pOJAFhz9p7ZFEv...
                   vvVsPaF0Ev9bk9pqhx269PB5Ox2KokwCagDMMaYvasWobuLmNu/1...
                   lmwRx7KTeQ7W1J3OLgxHA1QNMkip9c4Tb3q9vVc3t/fPf8vwfJ8C...
                   63g6N6rk2FkHZX1E62BgbewUd3eZOS05Ip4VUdvtGcuc8/qa+e5C...
                   KXgyt9nl64pMv+VaXfXkZhdLAdY0Khc9TGB9++VMSG5TrD15YJId...
                   gYALEI7m1jJKpHWAEs0hiemw5VmKyIZpzGstSJsFStERlAjiETDH...
                   YAtnI4J8dRyP9I7BOVOn3wNfIjk85gi1/0Oc+j8S65giLAfndWGR...
                   9R9wIkm5BMUcSRRcDy0yuwKBgEbkOnGGSD0ah4HkvrUkepIbUDTD...
                   AnEBM1cXI5UT7BfKInpUihZi59QhgdK/hkOSmWhlZGWikJ5VizBf...
                   drkBr/vTKVRMTi3lVFB7KkIV1xJxC5E/BZ+YdZEpWoCZAoGAC/Cd...
                   TTld5N6opgOXAcQJwzqoGa9ZMwc5Q9f4bfRc67emkw0ZAAwSsvWR...
                   x3O2duuy7/smTwWwskEWRK5IrUxoMv/VVYaqdzcOajwieNrblr7c...
                   -----END RSA PRIVATE KEY-----
```

O membro `KeyMaterial` armazena a chave privada do par de chaves. A chave pública é armazenada em AWS. Você não pode recuperar a chave pública de AWS, mas pode verificar a chave pública comparando a `KeyFingerprint` chave privada com a retornada da AWS chave pública.

## Exibição da impressão digital do seu par de chaves
<a name="get-ec2keypair"></a>

Você pode usar o cmdlet `Get-EC2KeyPair` para visualizar a impressão digital para o seu par de chaves.

```
PS > Get-EC2KeyPair -KeyName myPSKeyPair | format-list KeyName, KeyFingerprint

  KeyName        : myPSKeyPair
  KeyFingerprint : 09:06:70:8e:26:b6:e7:ef:8f:fe:4a:1d:bc:9c:6a:63:11:ac:ad:3c
```

## Armazenamento de sua chave privada
<a name="store-ec2keypair"></a>

Para armazenar a chave privada em um arquivo, insira o membro `KeyFingerMaterial` no cmdlet `Out-File`.

```
PS > $myPSKeyPair.KeyMaterial | Out-File -Encoding ascii myPSKeyPair.pem
```

Você deve especificar `-Encoding ascii` ao gravar a chave privada em um arquivo. Caso contrário, talvez as ferramentas, como `openssl`, não consigam ler o arquivo corretamente. Você pode verificar se o formato do arquivo resultante está correto usando um comando como o seguinte:

```
PS > openssl rsa -check < myPSKeyPair.pem
```

(A `openssl` ferramenta não está incluída com o Ferramentas da AWS para PowerShell ou AWS SDK para .NET o.)

## Exclusão do par de chaves
<a name="remove-ec2keypair"></a>

Você precisará de seu par de chaves para executar e conectar-se a uma instância. Depois que terminar de usar um par de chaves, você poderá removê-lo. Para remover a chave pública do AWS, use o `Remove-EC2KeyPair` cmdlet. Quando solicitado, pressione `Enter` para remover o par de chaves.

```
PS > Remove-EC2KeyPair -KeyName myPSKeyPair

Confirm
Performing the operation "Remove-EC2KeyPair (DeleteKeyPair)" on target "myPSKeyPair".
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):
```

A variável,`$myPSKeyPair`, ainda existe na PowerShell sessão atual e ainda contém as informações do par de chaves. O arquivo `myPSKeyPair.pem` também existe. No entanto, a chave privada não é mais válida porque a chave pública para o par de chaves não é mais armazenada na AWS.

# Crie um grupo de segurança usando o Windows PowerShell
<a name="pstools-ec2-sg"></a>

Você pode usar o Ferramentas da AWS para PowerShell para criar e configurar um grupo de segurança. A resposta é o ID do grupo de segurança.

Se você precisar se conectar à sua instância, deverá configurar o grupo de segurança para permitir o tráfego SSH (Linux) ou RDP (Windows).

**Topics**
+ [Pré-requisitos](#sg-prerequisites)
+ [Criação de um grupo de segurança para EC2 -VPC](#new-ec2securitygroup-vpc)

## Pré-requisitos
<a name="sg-prerequisites"></a>

Você precisará do endereço IP público do computador, na notação CIDR. Também é possível acessar um endereço IP público de seu computador local por meio de um serviço. Por exemplo, a Amazon fornece o seguinte serviço: [http://checkip.amazonaws.com/](http://checkip.amazonaws.com/) ou [https://checkip.amazonaws.com/](https://checkip.amazonaws.com/). Para localizar outro serviço que forneça o endereço IP, use a frase de busca "qual é o meu endereço IP". Se estiver conectado por meio de um ISP ou protegido por um firewall sem um endereço IP estático, localize o intervalo de endereços IP que pode ser usado pelos computadores cliente.

**Atenção**  
Se especificar `0.0.0.0/0`, você habilitará o tráfego de qualquer endereço IP no mundo. Para os protocolos SSH e RDP, essa abordagem é aceitável por um período curto em um ambiente de teste, mas não é seguro em ambientes de produção. Em produção, certifique-se de autorizar o acesso somente a partir do endereço IP individual apropriado ou do intervalo de endereços.

## Criação de um grupo de segurança para EC2 -VPC
<a name="new-ec2securitygroup-vpc"></a>

**Atenção**  
EC2-Classic foi aposentado em 15 de agosto de 2022. Recomendamos que você migre de EC2 -Classic para uma VPC. Para obter mais informações, consulte a postagem do blog [EC2- A rede clássica está se aposentando - veja como se preparar](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/).

O exemplo `New-EC2SecurityGroup` a seguir adiciona o parâmetro `-VpcId` para criar um grupo de segurança para a VPC especificada.

```
PS > $groupid = New-EC2SecurityGroup `
    -VpcId "vpc-da0013b3" `
    -GroupName "myPSSecurityGroup" `
    -GroupDescription "EC2-VPC from PowerShell"
```

Para exibir a configuração inicial do grupo de segurança, use o cmdlet `Get-EC2SecurityGroup`. Por padrão, o grupo de segurança de uma VPC contém uma regra de saída que permite todo o tráfego de saída. Observe que você não pode referenciar um grupo de segurança para EC2 -VPC pelo nome.

```
PS > Get-EC2SecurityGroup -GroupId sg-5d293231

OwnerId             : 123456789012
GroupName           : myPSSecurityGroup
GroupId             : sg-5d293231
Description         : EC2-VPC from PowerShell
IpPermissions       : {}
IpPermissionsEgress : {Amazon.EC2.Model.IpPermission}
VpcId               : vpc-da0013b3
Tags                : {}
```

Para definir as permissões para tráfego de entrada na porta TCP 22 (SSH) e na porta TCP 3389, use o cmdlet `New-Object`. O script de exemplo a seguir define permissões para as portas TCP 22 e 3389 de um único endereço IP, `203.0.113.25/32`.

```
$ip1 = new-object Amazon.EC2.Model.IpPermission 
$ip1.IpProtocol = "tcp" 
$ip1.FromPort = 22 
$ip1.ToPort = 22 
$ip1.IpRanges.Add("203.0.113.25/32") 
$ip2 = new-object Amazon.EC2.Model.IpPermission 
$ip2.IpProtocol = "tcp" 
$ip2.FromPort = 3389 
$ip2.ToPort = 3389 
$ip2.IpRanges.Add("203.0.113.25/32") 
Grant-EC2SecurityGroupIngress -GroupId $groupid -IpPermissions @( $ip1, $ip2 )
```

Para verificar se o grupo de segurança foi atualizado, use novamente o cmdlet `Get-EC2SecurityGroup`.

```
PS > Get-EC2SecurityGroup -GroupIds sg-5d293231

OwnerId             : 123456789012
GroupName           : myPSSecurityGroup
GroupId             : sg-5d293231
Description         : EC2-VPC from PowerShell
IpPermissions       : {Amazon.EC2.Model.IpPermission}
IpPermissionsEgress : {Amazon.EC2.Model.IpPermission}
VpcId               : vpc-da0013b3
Tags                : {}
```

Para exibir as regras de entrada, recupere a propriedade `IpPermissions` do objeto de coleção retornado pelo comando anterior.

```
PS > (Get-EC2SecurityGroup -GroupIds sg-5d293231).IpPermissions

IpProtocol       : tcp
FromPort         : 22
ToPort           : 22
UserIdGroupPairs : {}
IpRanges         : {203.0.113.25/32}

IpProtocol       : tcp
FromPort         : 3389
ToPort           : 3389
UserIdGroupPairs : {}
IpRanges         : {203.0.113.25/32}
```

# Encontre uma imagem de máquina da Amazon usando o Windows PowerShell
<a name="pstools-ec2-get-amis"></a>

Ao iniciar uma EC2 instância da Amazon, você especifica uma Amazon Machine Image (AMI) para servir como modelo para a instância. No entanto, o IDs para o AWS Windows AMIs muda com frequência porque AWS fornece as atualizações e aprimoramentos de segurança mais recentes. AMIs Você pode usar o [Get-EC2Image](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-EC2Image.html)cmdlet para encontrar o Windows atual AMIs e obter seu. IDs

## Get-EC2Image
<a name="pstools-ec2-get-image"></a>

O `Get-EC2Image` cmdlet recupera uma lista do AMIs que você pode usar.

Use o `-Owner` parâmetro com o valor da matriz `amazon, self` para `Get-EC2Image` recuperar somente os AMIs pertencentes à Amazon ou a você. Nesse contexto, *você* se refere ao usuário cujas credenciais foram usadas para invocar o cmdlet.

```
PS > Get-EC2Image -Owner amazon, self
```

Você pode limitar os resultados usando o parâmetro `-Filter`. Para especificar o filtro, crie um objeto do tipo `Amazon.EC2.Model.Filter`. Por exemplo, use o filtro a seguir para exibir somente o Windows AMIs.

```
$platform_values = New-Object 'collections.generic.list[string]'
$platform_values.add("windows")
$filter_platform = New-Object Amazon.EC2.Model.Filter -Property @{Name = "platform"; Values = $platform_values}
Get-EC2Image -Owner amazon, self -Filter $filter_platform
```

Veja a seguir um exemplo de um dos AMIs retornados pelo cmdlet; a saída real do comando anterior fornece informações para muitos. AMIs

```
Architecture        : x86_64
BlockDeviceMappings : {/dev/sda1, xvdca, xvdcb, xvdcc…}
CreationDate        : 2019-06-12T10:41:31.000Z
Description         : Microsoft Windows Server 2019 Full Locale English with SQL Web 2017 AMI provided by Amazon
EnaSupport          : True
Hypervisor          : xen
ImageId             : ami-000226b77608d973b
ImageLocation       : amazon/Windows_Server-2019-English-Full-SQL_2017_Web-2019.06.12
ImageOwnerAlias     : amazon
ImageType           : machine
KernelId            : 
Name                : Windows_Server-2019-English-Full-SQL_2017_Web-2019.06.12
OwnerId             : 801119661308
Platform            : Windows
ProductCodes        : {}
Public              : True
RamdiskId           : 
RootDeviceName      : /dev/sda1
RootDeviceType      : ebs
SriovNetSupport     : simple
State               : available
StateReason         : 
Tags                : {}
VirtualizationType  : hvm
```

**nota**  
A versão 4 do Ferramentas da AWS para PowerShell forneceu o `Get-EC2ImageByName` cmdlet para filtrar a lista de padrões AMIs por nome. Para a versão 5 das ferramentas, use o cmdlet [Get- SSMLatest EC2 Image](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-SSMLatestEC2Image.html) em vez disso.

# Inicie uma EC2 instância da Amazon usando o Windows PowerShell
<a name="pstools-ec2-launch"></a>

Para iniciar uma EC2 instância da Amazon, você precisa do par de chaves e do grupo de segurança que você criou nas seções anteriores. Você também precisa do ID de uma Imagem de máquina da Amazon (AMI). Para obter mais informações, consulte a seguinte documentação do :
+  [Criação de um par de chaves](pstools-ec2-keypairs.md) 
+  [Crie um grupo de segurança usando o Windows PowerShell](pstools-ec2-sg.md) 
+  [Encontre uma imagem de máquina da Amazon usando o Windows PowerShell](pstools-ec2-get-amis.md) 

**Importante**  
Se você executar uma instância que não esteja no nível gratuito, será faturado depois do início da instância e cobrado pelo tempo que executou a instância, mesmo se ela permanecer ociosa.

**Topics**
+ [Execução de uma instância em uma VPC](#new-ec2instance-vpc)
+ [Execução de uma instância spot em uma VPC](#new-ec2instance-spot)

## Execução de uma instância em uma VPC
<a name="new-ec2instance-vpc"></a>

**Atenção**  
EC2-Classic foi aposentado em 15 de agosto de 2022. Recomendamos que você migre de EC2 -Classic para uma VPC. Para obter mais informações, consulte a postagem do blog [EC2- A rede clássica está se aposentando - veja como se preparar](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/).

O comando a seguir cria uma única instância `m1.small` na sub-rede privada especificada. O grupo de segurança deve ser válido para a sub-rede especificada.

```
PS > New-EC2Instance `
    -ImageId ami-c49c0dac `
    -MinCount 1 -MaxCount 1 `
    -KeyName myPSKeyPair `
    -SecurityGroupId sg-5d293231 `
    -InstanceType m1.small `
    -SubnetId subnet-d60013bf

ReservationId   : r-b70a0ef1
OwnerId         : 123456789012
RequesterId     :
Groups          : {}
GroupName       : {}
Instances       : {}
```

A instância estará no estado `pending` inicialmente, mas passará para o estado `running` depois de alguns minutos. Para visualizar informações sobre sua instância, use o cmdlet `Get-EC2Instance`. Se você tiver mais de uma instância, poderá filtrar os resultados no ID de reserva usando o parâmetro `Filter`. Primeiro, crie um objeto do tipo `Amazon.EC2.Model.Filter`. Depois, chame `Get-EC2Instance`, que usa o filtro e exibe a propriedade `Instances`.

```
PS > $reservation = New-Object 'collections.generic.list[string]'
PS > $reservation.add("r-b70a0ef1")
PS > $filter_reservation = New-Object Amazon.EC2.Model.Filter -Property @{Name = "reservation-id"; Values = $reservation}
PS > (Get-EC2Instance -Filter $filter_reservation).Instances

AmiLaunchIndex        : 0
Architecture          : x86_64
BlockDeviceMappings   : {/dev/sda1}
ClientToken           :
EbsOptimized          : False
Hypervisor            : xen
IamInstanceProfile    :
ImageId               : ami-c49c0dac
InstanceId            : i-5203422c
InstanceLifecycle     :
InstanceType          : m1.small
KernelId              :
KeyName               : myPSKeyPair
LaunchTime            : 12/2/2018 3:38:52 PM
Monitoring            : Amazon.EC2.Model.Monitoring
NetworkInterfaces     : {}
Placement             : Amazon.EC2.Model.Placement
Platform              : Windows
PrivateDnsName        :
PrivateIpAddress      : 10.25.1.11
ProductCodes          : {}
PublicDnsName         :
PublicIpAddress       : 198.51.100.245
RamdiskId             :
RootDeviceName        : /dev/sda1
RootDeviceType        : ebs
SecurityGroups        : {myPSSecurityGroup}
SourceDestCheck       : True
SpotInstanceRequestId :
SriovNetSupport       :
State                 : Amazon.EC2.Model.InstanceState
StateReason           :
StateTransitionReason :
SubnetId              : subnet-d60013bf
Tags                  : {}
VirtualizationType    : hvm
VpcId                 : vpc-a01106c2
```

## Execução de uma instância spot em uma VPC
<a name="new-ec2instance-spot"></a>

O script de exemplo a seguir solicita uma Instância spot na sub-rede especificada. O grupo de segurança deve ser um que você criou para o VPC que contém a sub-rede especificada.

```
$interface1 = New-Object Amazon.EC2.Model.InstanceNetworkInterfaceSpecification
$interface1.DeviceIndex = 0
$interface1.SubnetId = "subnet-b61f49f0"
$interface1.PrivateIpAddress = "10.0.1.5"
$interface1.Groups.Add("sg-5d293231")
Request-EC2SpotInstance `
    -SpotPrice 0.007 `
    -InstanceCount 1 `
    -Type one-time `
    -LaunchSpecification_ImageId ami-7527031c `
    -LaunchSpecification_InstanceType m1.small `
    -Region us-west-2 `
    -LaunchSpecification_NetworkInterfaces $interface1
```

# AWS Lambda and Ferramentas da AWS para PowerShell
<a name="pstools-lambda"></a>

Ao usar o [AWSLambdaPSCore](https://www.powershellgallery.com/packages/AWSLambdaPSCore)módulo, você pode desenvolver AWS Lambda funções no PowerShell Core 6.0 usando o tempo de execução do.NET Core 2.1. PowerShell os desenvolvedores podem gerenciar AWS recursos e escrever scripts de automação no PowerShell ambiente usando o Lambda. PowerShell o suporte no Lambda permite que você execute PowerShell scripts ou funções em resposta a qualquer evento do Lambda, como um evento do Amazon S3 ou um evento agendado da Amazon. CloudWatch O AWSLambda PSCore módulo é um AWS módulo separado para PowerShell; ele não faz parte do Ferramentas da AWS para PowerShell, nem a instalação do AWSLambda PSCore módulo instala Ferramentas da AWS para PowerShell o.

Depois de instalar o AWSLambda PSCore módulo, você pode usar qualquer PowerShell cmdlet disponível — ou desenvolver o seu próprio — para criar funções sem servidor. O PowerShell módulo AWS Lambda Tools for inclui modelos de projeto para aplicativos sem servidor PowerShell baseados e ferramentas para publicar projetos. AWS

AWSLambdaPSCore o suporte ao módulo está disponível em todas as regiões que oferecem suporte ao Lambda. Para obter mais informações sobre as regiões com suporte, consulte [Tabela de regiões da AWS](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).

## Pré-requisitos
<a name="prerequisites"></a>

As etapas a seguir são necessárias antes que você possa instalar e usar o AWSLambda PSCore módulo. Para obter mais detalhes sobre essas etapas, consulte [Configurando um ambiente de PowerShell desenvolvimento](https://docs.aws.amazon.com/lambda/latest/dg/lambda-powershell-setup-dev-environment.html) no Guia do AWS Lambda desenvolvedor.
+  **Instale a versão correta do PowerShell** — O suporte do Lambda PowerShell é baseado na versão multiplataforma do PowerShell Core 6.0. Você pode desenvolver funções do PowerShell Lambda no Windows, Linux ou Mac. Se você não tiver pelo menos essa versão do PowerShell instalada, as instruções estão disponíveis no [site de PowerShell documentação da Microsoft](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell).
+  **Instale o SDK do.NET Core 2.1** — Como o PowerShell Core é baseado no.NET Core, o suporte PowerShell do Lambda usa o mesmo tempo de execução do.NET Core 2.1 Lambda para funções.NET Core e Lambda. PowerShell Os cmdlets de PowerShell publicação do Lambda usam o SDK do.NET Core 2.1 para criar o pacote de implantação do Lambda. O .NET Core 2.1 SDK está disponível na [Central de download da Microsoft](https://www.microsoft.com/net/download). Certifique-se de instalar o SDK, e não o Runtime.

## Instale o AWSLambda PSCore módulo
<a name="install-the-awslambdapscore-module"></a>

Depois de concluir os pré-requisitos, você estará pronto para instalar o módulo. AWSLambda PSCore Execute o comando a seguir em uma sessão PowerShell principal.

```
PS> Install-Module AWSLambdaPSCore -Scope CurrentUser
```

Você está pronto para começar a desenvolver funções Lambda em. PowerShell Para obter mais informações sobre como começar, consulte [Modelo de programação para criação de funções Lambda PowerShell no Guia](https://docs.aws.amazon.com/lambda/latest/dg/powershell-programming-model.html) AWS Lambda do desenvolvedor.

## Consulte também
<a name="see-also"></a>
+  [Anunciando o Lambda PowerShell Support para Core AWS no blog do desenvolvedor](https://aws.amazon.com/blogs/developer/announcing-lambda-support-for-powershell-core/) 
+  [AWSLambdaPSCore módulo no site da PowerShell Galeria](https://www.powershellgallery.com/packages/AWSLambdaPSCore/1.0.0.2) 
+  [Configurando um ambiente PowerShell de desenvolvimento](https://docs.aws.amazon.com/lambda/latest/dg/lambda-powershell-setup-dev-environment.html) 
+ [AWS Ferramentas Lambda para Powershell em GitHub](https://github.com/aws/aws-lambda-dotnet/tree/master/PowerShell)
+  [AWS Console Lambda](https://console.aws.amazon.com/lambda/home) 

# Amazon SQS, Amazon SNS e ferramentas para Windows PowerShell
<a name="pstools-sqs-queue-sns-topic"></a>

Esta seção fornece exemplos que mostram como:
+ Crie uma fila do Amazon SQS e obtenha o nome do recurso da Amazon (ARN) da fila.
+ Crie um tópico do Amazon SNS.
+ Fornecer permissões ao tópico do SNS para que ele possa enviar mensagens à fila.
+ Assinar a fila para o tópico do SNS
+ Conceda aos usuários ou AWS contas do IAM permissões para publicar no tópico do SNS e ler mensagens da fila do SQS.
+ Verificar resultados publicando uma mensagem no tópico e lendo a mensagem da fila.

## Crie uma fila do Amazon SQS e obtenha o nome do recurso da Amazon (ARN)
<a name="pstools-create-sqs-queue"></a>

O comando a seguir cria uma fila do SQS em sua região padrão. A saída mostra o URL da nova fila.

```
PS > New-SQSQueue -QueueName myQueue
https://sqs.us-west-2.amazonaws.com/123456789012/myQueue
```

O comando a seguir recupera o ARN da fila.

```
PS > Get-SQSQueueAttribute -QueueUrl https://sqs.us-west-2.amazonaws.com/123456789012/myQueue -AttributeName QueueArn
...
QueueARN               : arn:aws:sqs:us-west-2:123456789012:myQueue
...
```

## Crie um tópico do Amazon SNS
<a name="pstools-create-sns-topic"></a>

O comando a seguir cria um tópico SNS em sua região padrão e retorna o ARN do novo tópico.

```
PS > New-SNSTopic -Name myTopic
arn:aws:sns:us-west-2:123456789012:myTopic
```

## Fornecer permissões ao tópico do SNS
<a name="pstools-permissions-sns-topic"></a>

O script de exemplo a seguir cria uma fila do SQS e um tópico SNS e concede permissões ao tópico SNS para que ele possa enviar mensagens para a fila do SQS:

```
# create the queue and topic to be associated
$qurl = New-SQSQueue -QueueName "myQueue"
$topicarn = New-SNSTopic -Name "myTopic"

# get the queue ARN to inject into the policy; it will be returned
# in the output's QueueARN member but we need to put it into a variable
# so text expansion in the policy string takes effect
$qarn = (Get-SQSQueueAttribute -QueueUrl $qurl -AttributeNames "QueueArn").QueueARN

# construct the policy and inject arns
$policy = @"
{
    "Version": "2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Principal": "*",
        "Action": "SQS:SendMessage",
        "Resource": "$qarn",
        "Condition": { "ArnEquals": { "aws:SourceArn": "$topicarn" } }
    }
}
"@

# set the policy
Set-SQSQueueAttribute -QueueUrl $qurl -Attribute @{ Policy=$policy }
```

## Assinar a fila para o tópico do SNS
<a name="pstools-subscribe-queue-topic"></a>

O comando a seguir inscreve a fila `myQueue` no tópico SNS `myTopic` e retorna o ID da inscrição:

```
PS > Connect-SNSNotification `
    -TopicARN arn:aws:sns:us-west-2:123456789012:myTopic `
    -Protocol SQS `
    -Endpoint arn:aws:sqs:us-west-2:123456789012:myQueue
arn:aws:sns:us-west-2:123456789012:myTopic:f8ff77c6-e719-4d70-8e5c-a54d41feb754
```

## Fornecer permissões
<a name="pstools-permissions-publish-read"></a>

O comando a seguir fornece a permissão para executar a ação `sns:Publish` no tópico `myTopic`

```
PS > Add-SNSPermission `
    -TopicArn arn:aws:sns:us-west-2:123456789012:myTopic `
    -Label ps-cmdlet-topic `
    -AWSAccountIds 123456789012 `
    -ActionNames publish
```

O comando a seguir fornece a permissão para executar as ações `sqs:ReceiveMessage` e `sqs:DeleteMessage` na fila `myQueue`

```
PS > Add-SQSPermission `
    -QueueUrl https://sqs.us-west-2.amazonaws.com/123456789012/myQueue `
    -AWSAccountId "123456789012" `
    -Label queue-permission `
    -ActionName SendMessage, ReceiveMessage
```

## Verificar os resultados
<a name="pstools-verify-publish-read"></a>

O comando a seguir testa sua nova fila e tópico publicando uma mensagem no tópico SNS `myTopic` e retorna o `MessageId`.

```
PS > Publish-SNSMessage `
    -TopicArn arn:aws:sns:us-west-2:123456789012:myTopic `
    -Message "Have A Nice Day!"
728180b6-f62b-49d5-b4d3-3824bb2e77f4
```

O comando a seguir recupera a mensagem da fila `myQueue` do SQS e a exibe.

```
PS > Receive-SQSMessage -QueueUrl https://sqs.us-west-2.amazonaws.com/123456789012/myQueue

Attributes             : {}
Body                   : {
                           "Type" : "Notification",
                           "MessageId" : "491c687d-b78d-5c48-b7a0-3d8d769ee91b",
                           "TopicArn" : "arn:aws:sns:us-west-2:123456789012:myTopic",
                           "Message" : "Have A Nice Day!",
                           "Timestamp" : "2019-09-09T21:06:27.201Z",
                           "SignatureVersion" : "1",
                           "Signature" : "llE17A2+XOuJZnw3TlgcXz4C4KPLXZxbxoEMIirelhl3u/oxkWmz5+9tJKFMns1ZOqQvKxk+ExfEZcD5yWt6biVuBb8pyRmZ1bO3hUENl3ayv2WQiQT1vpLpM7VEQN5m+hLIiPFcs
                         vyuGkJReV7lOJWPHnCN+qTE2lId2RPkFOeGtLGawTsSPTWEvJdDbLlf7E0zZ0q1niXTUtpsZ8Swx01X3QO6u9i9qBFt0ekJFZNJp6Avu05hIklb4yoRs1IkbLVNBK/y0a8Yl9lWp7a7EoWaBn0zhCESe7o
                         kZC6ncBJWphX7KCGVYD0qhVf/5VDgBuv9w8T+higJyvr3WbaSvg==",
                           "SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-6aad65c2f9911b05cd53efda11f913f9.pem",
                           "UnsubscribeURL" : 
                         "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:myTopic:22b77de7-a216-4000-9a23-bf465744ca84"
                         }
MD5OfBody              : 5b5ee4f073e9c618eda3718b594fa257
MD5OfMessageAttributes : 
MessageAttributes      : {}
MessageId              : 728180b6-f62b-49d5-b4d3-3824bb2e77f4
ReceiptHandle          : AQEB2vvk1e5cOKFjeIWJticabkc664yuDEjhucnIOqdVUmie7bX7GiJbl7F0enABUgaI2XjEcNPxixhVc/wfsAJZLNHnl8SlbQa0R/kD+Saqa4OIvfj8x3M4Oh1yM1cVKpYmhAzsYrAwAD5g5FvxNBD6zs
                         +HmXdkax2Wd+9AxrHlQZV5ur1MoByKWWbDbsqoYJTJquCclOgWIak/sBx/daBRMTiVQ4GHsrQWMVHtNC14q7Jy/0L2dkmb4dzJfJq0VbFSX1G+u/lrSLpgae+Dfux646y8yFiPFzY4ua4mCF/SVUn63Spy
                         sHN12776axknhg3j9K/Xwj54DixdsegnrKoLx+ctI+0jzAetBR66Q1VhIoJAq7s0a2MseyOeM/Jjucg6Sr9VUnTWVhV8ErXmotoiEg==
```

# CloudWatch do AWS Tools for Windows PowerShell
<a name="pstools-cw"></a>

Esta seção mostra um exemplo de como usar as Ferramentas do Windows PowerShell para publicar dados métricos personalizados em CloudWatch.

Este exemplo pressupõe que você definiu credenciais padrão e uma região padrão para sua PowerShell sessão. 

## Publique uma métrica personalizada em seu CloudWatch painel
<a name="pstools-cw-custom-metric-publish"></a>

O PowerShell código a seguir inicializa um CloudWatch `MetricDatum` objeto e o publica no serviço. Você pode ver o resultado dessa operação navegando até o [CloudWatch console](https://console.aws.amazon.com/cloudwatch/home).

```
$dat = New-Object Amazon.CloudWatch.Model.MetricDatum
$dat.Timestamp = (Get-Date).ToUniversalTime()
$dat.MetricName = "New Posts"
$dat.Unit = "Count"
$dat.Value = ".50"
Write-CWMetricData -Namespace "Usage Metrics" -MetricData $dat
```

Observe o seguinte:
+ As informações de data/hora usadas para inicializar `$dat.Timestamp` devem estar no Horário Universal (UTC).
+ O valor usado para inicializar `$dat.Value` pode ser de um valor de string entre aspas ou um valor numérico (sem aspas). O exemplo mostra um valor de string.

## Consulte também
<a name="see-also"></a>
+  [AWS Serviços de chamadas no Ferramentas da AWS para PowerShell](pstools-using.md) 
+  [AmazonCloudWatchClient. PutMetricData](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/CloudWatch/MCloudWatchPutMetricDataPutMetricDataRequest.html)(Referência do SDK.NET)
+  [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html)(Referência da API de serviço)
+  [ CloudWatch Console Amazon](https://console.aws.amazon.com/cloudwatch/home) 

# Usando o ClientConfig parâmetro em cmdlets
<a name="pstools-clientconfig"></a>

O parâmetro `ClientConfig` pode ser usado para especificar determinadas configurações quando você se conecta a um serviço. A maioria das propriedades possíveis desse parâmetro é definida na [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Runtime/TClientConfig.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Runtime/TClientConfig.html)classe, que é herdada em APIs for AWS services. Para obter um exemplo de herança simples, veja a classe [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Keyspaces/TKeyspacesConfig.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Keyspaces/TKeyspacesConfig.html). Além disso, alguns serviços definem propriedades adicionais que são apropriadas somente para esse serviço. Para ver um exemplo de propriedades adicionais que foram definidas, consulte a classe [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TS3Config.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/S3/TS3Config.html), especificamente a propriedade `ForcePathStyle`.

## Usar o parâmetro `ClientConfig`
<a name="clientconfig-operation"></a>

Para usar o `ClientConfig` parâmetro, você pode especificá-lo na linha de comando como um `ClientConfig` objeto ou usar o PowerShell splatting para passar uma coleção de valores de parâmetros para um comando como uma unidade. Esses métodos são mostrados nos exemplos a seguir. Os exemplos pressupõem que o módulo `AWS.Tools.S3` tenha sido instalado e importado e que você tenha um perfil de credenciais `[default]` com as permissões apropriadas.

******Definir um objeto `ClientConfig`**

```
$s3Config = New-Object -TypeName Amazon.S3.AmazonS3Config
$s3Config.ForcePathStyle = $true
$s3Config.Timeout = [TimeSpan]::FromMilliseconds(150000)
Get-S3Object -BucketName <BUCKET_NAME> -ClientConfig $s3Config
```

**Adicionar `ClientConfig` propriedades usando PowerShell respingos**

```
$params=@{
    ClientConfig=@{
        ForcePathStyle=$true
        Timeout=[TimeSpan]::FromMilliseconds(150000)
    }
    BucketName="<BUCKET_NAME>"
}

Get-S3Object @params
```

## Usar uma propriedade indefinida
<a name="clientconfig-undefined"></a>

Ao usar o PowerShell splatting, se você especificar uma `ClientConfig` propriedade que não existe, ela Ferramentas da AWS para PowerShell não detectará o erro até o tempo de execução, quando retornará uma exceção. Modificação do exemplo acima:

```
$params=@{
    ClientConfig=@{
        ForcePathStyle=$true
        UndefinedProperty="Value"
        Timeout=[TimeSpan]::FromMilliseconds(150000)
    }
    BucketName="<BUCKET_NAME>"
}

Get-S3Object @params
```

Esse exemplo gerará uma exceção semelhante à seguinte:

```
Cannot bind parameter 'ClientConfig'. Cannot create object of type "Amazon.S3.AmazonS3Config". The UndefinedProperty property was not found for the Amazon.S3.AmazonS3Config object.
```

## Especificando o Região da AWS
<a name="clientconfig-region"></a>

Você pode usar o `ClientConfig` parâmetro para definir o Região da AWS para o comando. A região é definida por meio da propriedade `RegionEndpoint`. O Ferramentas da AWS para PowerShell calcula a região a ser usada de acordo com a seguinte precedência:

1. O parâmetro `-Region`

1. A região transmitida no parâmetro `ClientConfig`

1. O estado PowerShell da sessão

1. O AWS `config` arquivo compartilhado

1. As variáveis de ambiente

1. Os metadados da EC2 instância da Amazon, se habilitados.