Como funciona Configuração do preenchimento automático de comando no Linux ou no macOS Configuração do preenchimento de comandos no Windows

Configurando a conclusão do comando no AWS CLI

O AWS Command Line Interface (AWS CLI) inclui um recurso de conclusão de comando compatível com bash que permite usar a tecla Tab para concluir um comando parcialmente inserido. Na maioria dos sistemas, esse recurso deve ser configurado manualmente.

Em vez disso, para obter informações sobre o recurso de solicitação automática da AWS CLI versão 2, consulteAtivando e usando os prompts de comando no AWS CLI.

Tópicos

Como funciona
Configuração do preenchimento automático de comando no Linux ou no macOS
Configuração do preenchimento de comandos no Windows

Como funciona

Ao inserir parcialmente um comando, um parâmetro ou uma opção, o recurso de conclusão de comando conclui automaticamente o comando ou exibe uma lista sugerida de comandos. Para solicitar a conclusão do comando, você insere parcialmente um comando e pressiona a tecla de conclusão, que normalmente é Tab na maioria das conchas.

Os exemplos a seguir mostram diferentes maneiras de usar a conclusão de comando:

Insira parcialmente um comando e pressione Tab para exibir uma lista sugerida de comandos.


$ aws dynamodb dTAB
delete-backup                        describe-global-table
delete-item                          describe-global-table-settings
delete-table                         describe-limits
describe-backup                      describe-table
describe-continuous-backups          describe-table-replica-auto-scaling
describe-contributor-insights        describe-time-to-live
describe-endpoints

Insira parcialmente um parâmetro e pressione Tab para exibir uma lista sugerida de parâmetros.


$ aws dynamodb delete-table --TAB
--ca-bundle              --endpoint-url           --profile              
--cli-connect-timeout    --generate-cli-skeleton  --query                
--cli-input-json         --no-paginate            --region               
--cli-read-timeout       --no-sign-request        --table-name           
--color                  --no-verify-ssl          --version              
--debug                  --output

Insira um parâmetro e pressione Tab para exibir uma lista sugerida de valores de recursos. Esse recurso está disponível somente na AWS CLI versão 2.
```
$ aws dynamodb db delete-table --table-name TAB
Table 1                  Table 2                  Table 3
```

Configuração do preenchimento automático de comando no Linux ou no macOS

Para configurar o preenchimento automático de comandos no Linux ou macOS, você deve conhecer o nome do shell que está usando e a localização do script aws_completer.

nota

A conclusão de comandos é automaticamente configurada e ativada por padrão nas EC2 instâncias da Amazon que executam o Amazon Linux.

Tópicos

Confirme se a pasta do completer está na variável path
Habilitar a conclusão de comando
Verifique o preenchimento de comandos

Confirme se a pasta do completer está na variável path

Para que o AWS completador funcione com sucesso, ele aws_completer precisa estar no caminho do seu shell. O comando which pode verificar se o completer está na variável path.


$ which aws_completer
/usr/local/bin/aws_completer

Se o comando que não conseguir encontrar o completer, use as etapas a seguir para adicionar a pasta do completer à variável PATH.

Etapa 1: localize o AWS completador

A localização do AWS completador pode variar dependendo do método de instalação usado.

Package Manager - Programas comopip, yumbrew, e apt-get normalmente instalam o AWS completador (ou um link simbólico para ele) em um local de caminho padrão.
- Se você usou o pip sem o parâmetro --user, o caminho padrão é /usr/local/bin/aws_completer.
- Se você usou o pip com o parâmetro --user, o caminho padrão é /home/username/.local/bin/aws_completer.
Instalador empacotado: se você usou o instalador empacotado, o caminho padrão é /usr/local/bin/aws_completer.

Se tudo mais falhar, você pode usar o find comando para pesquisar o AWS completador em seu sistema de arquivos.


$ find / -name aws_completer
/usr/local/bin/aws_completer

Etapa 2: Identificar o shell

Para identificar qual shell você está usando, é possível usar um dos seguintes comandos.

echo $ SHELL — Exibe o nome do arquivo do programa do shell. Isso geralmente corresponde ao nome do shell em uso, a menos que você tenha iniciado um shell diferente após fazer o login.
```
$ echo $SHELL
/bin/bash
```

ps: exibe os processos em execução para o usuário atual. Um deles é o shell.


$ ps
  PID TTY          TIME CMD
 2148 pts/1    00:00:00 bash
 8756 pts/1    00:00:00 ps

Etapa 3: Adicionar o completer ao caminho

Encontre o script de perfil do shell em sua pasta de usuário.
```
$ ls -a ~/
.  ..  .bash_logout  .bash_profile  .bashrc  Desktop  Documents  Downloads
```
- Bash: .bash_profile, .profile ou .bash_login
- Zsh: .zshrc
- Tcsh: .tcshrc, .cshrc ou .login
Adicione um comando de exportação ao final do script de perfil que é semelhante ao exemplo a seguir. Substitua /usr/local/bin/ pela pasta que você descobriu na seção anterior.
```
export PATH=/usr/local/bin/:$PATH
```
Recarregue o perfil na sessão atual para colocar essas alterações em vigor. Substitua .bash_profile pelo nome do script de shell que você descobriu na primeira seção.
```
$ source ~/.bash_profile
```

Habilitar a conclusão de comando

Depois de confirmar que o completer está no caminho, habilite a conclusão de comando executando o comando apropriado para o shell que você está usando. Você pode adicionar o comando ao perfil do shell para executá-lo cada vez que você abrir um novo shell. Em cada comando, substitua o /usr/local/bin/ caminho com aquele encontrado em seu sistema emConfirme se a pasta do completer está na variável path.

bash: usa o comando interno complete.
```
$ complete -C '/usr/local/bin/aws_completer' aws
```
Adicione o comando anterior ao ~/.bashrc para executá-lo cada vez que você abrir um novo shell. O ~/.bash_profile deve se basear em ~/.bashrc para garantir que o comando também seja executado em shells de login.
zsh: para executar o preenchimento de comandos, é necessário executar bashcompinit adicionando a seguinte linha de carregamento automático ao final do script do perfil ~/.zshrc.
```
$ autoload bashcompinit && bashcompinit
$ autoload -Uz compinit && compinit
```
Para habilitar a conclusão de comando, use o comando interno complete.
```
$ complete -C '/usr/local/bin/aws_completer' aws
```
Adicione os comandos anteriores ao ~/.zshrc para executá-los cada vez que você abrir um novo shell.
tcsh: o preenchimento para tcsh utiliza um tipo de palavra e padrão para definir o comportamento do preenchimento.
```
> complete aws 'p/*/`aws_completer`/'
```
Adicione o comando anterior ao ~/.tschrc para executá-lo cada vez que você abrir um novo shell.

Depois de habilitar o preenchimento automático de comandos, Verifique o preenchimento de comandos está funcionando.

Verifique o preenchimento de comandos

Após habilitar o preenchimento de comandos, insira um comando parcial e pressione Tab para ver os comandos disponíveis.


$ aws sTAB
s3              ses             sqs             sts             swf
s3api           sns             storagegateway  support

Configuração do preenchimento de comandos no Windows

nota

Para obter informações sobre como PowerShell lidar com sua conclusão, incluindo suas várias chaves de conclusão, consulte about_tab_Expansion no Microsoft Docs. PowerShell

Para habilitar a conclusão de comandos PowerShell no Windows, conclua as etapas a seguir em PowerShell.

Abra o arquivo $PROFILE com o comando a seguir.
```
PS C:\> Notepad $PROFILE
```
Se você ainda não tiver um $PROFILE, use o procedimento a seguir para criar um perfil de usuário.
```
PS C:\> if (!(Test-Path -Path $PROFILE ))
{ New-Item -Type File -Path $PROFILE -Force }
```
Para obter mais informações sobre PowerShell perfis, consulte Como usar perfis no Windows PowerShell ISE no site do Microsoft Docs.

Para ativar o preenchimento de comandos, adicione o seguinte bloco de código ao seu perfil, salve e, em seguida, feche o arquivo.


Register-ArgumentCompleter -Native -CommandName aws -ScriptBlock {
    param($commandName, $wordToComplete, $cursorPosition)
        $env:COMP_LINE=$wordToComplete
        if ($env:COMP_LINE.Length -lt $cursorPosition){
            $env:COMP_LINE=$env:COMP_LINE + " "
        }
        $env:COMP_POINT=$cursorPosition
        aws_completer.exe | ForEach-Object {
            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
        }
        Remove-Item Env:\COMP_LINE     
        Remove-Item Env:\COMP_POINT  
}

Depois de habilitar a conclusão dos comandos, recarregue o shell, insira um comando parcial e pressione Tab para percorrer os comandos disponíveis.
```
$ aws sTab
```
```
$ aws s3
```
Para ver todos os comandos disponíveis para conclusão, insira um comando parcial e pressione Ctrl + Espaço.
```
$ aws sCtrl + Space
s3              ses             sqs             sts             swf
s3api           sns             storagegateway  support
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Opções de linha de comando no AWS CLI

Repetições