The Ops Community ⚙️: Francilio Araújo

Como conseguir ajuda sobre TI e ajudar de forma eficiente

Francilio Araújo — Fri, 09 Sep 2022 19:29:07 +0000

Há diversas comunidades de tecnologia espalhadas por diversas plataformas, como telegram, slack, discord, gitter, matrix, twitter, etc. Estas comunidades podem ser utilizadas para compartilhar conhecimento, tirar dúvidas e auxiliar na resolução de problemas. Pessoas com os mais variados níveis de experiência interagem nestas comunidades. Neste texto reuni algumas dicas para conseguir ajuda e ajudar nessas comunidades de forma eficiente. Cada item é clicável para dar mais detalhes.

Para quem procura ajuda

1. Não diga apenas olá, ou pergunte se pode perguntar

Ao enviar apenas um 'olá' ou similares e esperar alguém responder para poder mandar a pergunta, você estará perdendo o tempo que poderia estar respondendo a sua pergunta. Além disso, nada garante que a pessoa que responder estará disponível para dar uma segunda resposta.

Da mesma forma, não pergunte coisas do tipo 'posso fazer uma pergunta sobre X aqui?', ou 'alguém aqui entende de X?'. Assumindo que você está no local certo, só estará perdendo tempo.

As pessoas que estão ali para responder podem estar fazendo outras atividades ao mesmo tempo e é escolha delas se elas terão tempo para responder só uma pergunta, ou as perguntas subsequentes, ou até mesmo não responder.

2. Antes de recorrer à comunidade, use o Google e o manual

Saber utilizar bem o google é uma das mais poderosas ferramentas de uma pessoa que trabalha em tecnologia. É bem provável que outra pessoa tenha tido o mesmo problema e escreveu a solução em algum StackOverflow, fórum ou blog, ou até fez um vídeo. Procurar a solução no google pode te poupar tempo.

A documentação oficial (ou manual) deve ser uma das primeiras fontes de informação sobre alguma linguagem, biblioteca, sistema ou ferramenta. Vários softwares atuais possuem boas documentações que abrangem todos os níveis de experiência, além de blogs com bastante informação extra. Ler a documentação oficial é um passo importante para utilizar um software de forma efetiva.

3. Faça as perguntas certas nos locais corretos

Em um grupo sobre docker, perguntas sobre docker. Em um grupo de python, perguntas sobre python. Não pergunte sobre coisas que não tem a ver com o propósito do grupo. Isso é tratado como off-topic e alguns grupos possuem políticas rígidas contra isso. Caso você não conheça um grupo específico sobre isso, pode perguntar à comunidade se alguém conhece um local apropriado.

Se você tem uma pergunta que parece pertencer a múltiplos grupos primeiro tente entender em que parte o problema está acontecendo para direcionar para o grupo correto. Por exemplo, 'tenho um código python executando em docker que está retornando X quando faço Y e deveria retornar Z'. A primeiro momento isso pode ser erro no código, então deveria ser perguntado em um grupo de python. Caso você tenha evidências de que o problema é com docker, então está no contexto do grupo de docker.

Código de conduta das comunidades de TI brasileiras

4. Descreva sua questão de forma clara e concisa

A pessoa terá de entender bem a sua pergunta para dar respostas adequadas. No mínimo a pessoa precisará de uma descrição do problema e sob quais condições ele ocorre. Dependendo do problema, serão necessárias mais informações, como ambiente, execução e código. Se estas informações são importantes para entender o problema, entregue-as junto à pergunta, não espere alguém solicitá-las. Descreva também outras tentativas que você já fez para tentar resolver o problema.

Não envie fotos de código, ou texto muito grande. As outras pessoas podem estar utilizando equipamentos com telas menores, ou terem problemas de visão, e uma imagem é bastante incômoda nestes cenários. Só envie imagens se forem realmente necessárias. Em casos de textos grandes, como logs, ou códigos grandes, utilize um site como https://pastebin.com/ e envie apenas o link.

Filtre informações que possam não ser relevantes para o problema. É muito mais fácil uma pessoa ler um log de poucas linhas do que um log de 200 para resolver o problema de outra pessoa. Lembre que as outras pessoas podem estar realizando outras tarefas naquele instante.

5. Seja paciente com as respostas

Caso sua pergunta não tenha sido respondida após alguns minutos, mas ela ainda é a última mensagem enviada, não envie outra para 'relembrar'. Podem haver diversos motivos para ninguém ter respondido ainda, como a pessoa não se sentir capaz de responder, ou não ter tempo. Caso sua mensagem esteja atrás de diversas outras mensagens, pode mandar um lembrete respondendo à própria mensagem.

6. Não mande mensagem em privado sem o consentimento da pessoa

Imagina que você faz trabalho voluntário de dar aula de tricô e um dos alunos vai na sua casa pedir uma aula particular. Não é uma situação agradável, não é? Da mesma forma em comunidades online. É de bom tom perguntar pelo consentimento da pessoa antes de chamá-la por mensagem privada. A pessoa pode ter de dedicar a atenção a outros assuntos.

Outro motivo para não fazer isso é que algumas plataformas são infestadas de spam. Por exemplo, no telegram é comum pessoas irem no privado para oferecer investimento em criptomoedas. Sem pedir o consentimento da pessoa, você pode ser confundido com um spam e ser ignorado ou até bloqueado.

7. Se conseguir resolver por outros meios, adicione como resposta

O problema que você passou pode servir de referência para outra pessoa. Se você encontrou a solução, pode ajudar outra pessoa no futuro. Deixar uma mensagem 'encontrei a solução. Caso alguém tenha o mesmo problema é só entrar em contato comigo' não é produtiva, pois quem garante que você estará disponível para responder quando alguém precisar? E a solução que você encontrou pode servir de aprendizado para as pessoas que não estavam seguras em ajudar.

8. Dê um retorno às respostas

Caso alguma resposta tenha resolvido, agradeça. Aquela pessoa dedicou atenção e tempo para pensar, pesquisar e responder à sua pergunta. Saber se deu certo ou não pode ser uma chance de aprendizado para a pessoa que respondeu. Mesmo que não tenha funcionado, retorne com o resultado.

Para quem responde

1. Se a pergunta não for pertinente, redirecione para o local correto

Pessoas com menos experiência podem ter dificuldade em afunilar a causa de um problema. Caso você esteja certo que a pergunta não pertence ao grupo, mas conhece outro que possa respondê-la, então responda com um direcionamento pro grupo e alguma informação que ajude a deixar a pergunta mais clara.

2. Seja humilde. Deixe claro se você tem certeza da resposta, ou se é um palpite

A pessoa que está perguntando pode estar com pressa pela resposta. Evite 'tiros no escuro', a não ser que sejam necessários. A pessoa que pergunta pode aprender algo com a resposta. Caso demore a chegar no objetivo, mais difícil será tirar um aprendizado.

Em um processo de troubleshoot pode ser necessário testar algumas hipóteses, neste caso deixe claro que é um teste, qual a hipótese e qual o resultado esperado.

Melhor do que uma resposta que leva a lugar nenhum é nenhuma resposta. Uma comunidade não é sobre ego, mas sim sobre ajudar.

3. Responda a pergunta, ou explique por que é uma resposta ruim e dê alternativas

Se uma pessoa pergunta sobre 'A', não responda simplesmente que é melhor fazer 'B'. A pessoa não aprenderá nada assim. Explique por que fazer 'A' é ruim e aí fale como a alternativa 'B' é melhor. Assim a pessoa resolve o problema e ainda aprende boas práticas.

4. Seja claro na resposta

A pessoa que está perguntando pode não ter o mesmo 'repertório' que você. Considere adicionar informações que considere relevantes e não utilize termos que não possam ser facilmente associados ao tema.

Se possível, indique links para a leitura, de preferência da documentação oficial ou de blogs relevantes.

5. Seja educado ao responder

Evite emitir juízos sobre a pergunta, isso pode ser interpretado como ataque pessoal. Caso seja necessário emitir algum juízo, um alerta para má prática por exemplo, não faça parecer que a pergunta é estúpida. Se você expor dados concretos, dificilmente será interpretado como ataque pessoal. Lembre que seu filtro tátil pode ser diferente do filtro da outra pessoa.

Tact Filters

Introdução ao prometheus

Francilio Araújo — Tue, 06 Sep 2022 17:02:28 +0000

Prometheus é um sistema open source de coleta, armazenamento, consulta e exibição de métricas. Ele foi construído dentro da SoundCloud por engenheiros que já tinham trabalhado com o sistema de monitoramento do Borg, antecessor do kubernetes. Prometheus foi o segundo projeto a fazer parte da Cloud Native Computing Foundation, logo após o kubernetes.
O prometheus armazena as métricas como séries temporais, ou seja, os valores são armazenados junto ao timestamp de quando eles foram coletados e, opcionalmente, algumas labels.

Funcionalidades

Um modelo de dados multi-dimensional com dados de séries temporais identificados por nome e pares chave/valor;
PromQL, uma linguagem de consulta flexível e capaz de lidar com esta dimensionalidade;
Não depende de armazenamento distribuído. Nós single server são autônomos;
Coleta de séries temporais ocorre por pull sobre HTTP;
Push de séries temporais é suportado por meio de um gateway intermediário;
Alvos são listados por meio de service discovery ou configuração estática;
Suporte a múltiplos modos para geração de gráficos e dashboards.

Arquitetura

O diagrama a seguir ilustra os componentes do prometheus e a relação com outras ferramentas do ecosistema:

O prometheus gera uma lista de endpoints em que ele coletará os dados. Ele suporta listar endpoints de provedores de cloud, como AWS, Azure, GCP, Digital Ocean e Linode, de orquestradores, como Hashicorp Nomad e Kubernetes, de sistemas de service discovery, como Eureka e Hashicorp Consul, além de arquivos, endpoints HTTP, DNS, hosts docker e vários outros métodos.
Após listar os alvos, o prometheus realiza uma requisição em cada um para coletar as métricas. Um alvo pode ser uma aplicação instrumentada, um exporter ou um pushgateway.
Uma aplicação instrumentada é uma aplicação que utiliza uma biblioteca cliente do prometheus. Um exporter é uma aplicação que coleta dados de um processo ou serviço e os disponibiliza no formato do prometheus. O pushgateway é uma aplicação intermediária entre o prometheus e processos de curta duração. Como processos de curta duração podem terminar antes do prometheus realizar a coleta, pode-se enviar as métricas para o pushgateway e o prometheus fará a coleta nele.
Os dados coletados são armazenados localmente no disco.
O prometheus pode enviar notificações para o alertmanager para sinalizar valores fora do esperado.
Outras ferramentas podem consultar os dados do prometheus utilizando PromQL para visualização e exportação.

Primeiros passos com docker

Para realizar este hands-on você vai precisar do docker e docker compose (prefira o plugin). Como base vamos utilizar este repositório:

francilioaraujo / monitoring-labs

0. Preparação

Realize o checkout da branch part01 e suba o contêiner pelo compose:

$ git checkout part01
Switched to branch 'part01'
Your branch is up to date with 'origin/part01'.
$ ls -F
docker-compose.yaml # Compose com todos os 'nós'
get-ip-for*         # Script para exibir o IP de um contêiner
prometheus/         # Pasta com o Dockerfile para o prometheus
$ docker compose up -d
[+] Building 17.4s (6/6) FINISHED                                              
 => [internal] load build definition from Dockerfile                      1.3s
 => => transferring dockerfile: 115B                                      0.3s
 => [internal] load .dockerignore                                         1.2s
 => => transferring context: 2B                                           0.0s
 => [internal] load metadata for docker.io/library/debian:bullseye        0.2s
 => CACHED [1/2] FROM docker.io/library/debian:bullseye                   0.0s
 => [2/2] RUN apt-get update &&     apt-get install -y wget vim          14.4s
 => exporting to image                                                    0.8s
 => => exporting layers                                                   0.8s
 => => writing image sha256:a4106420c75c87f084254dd950583c6320c90f9767c2  0.0s 
 => => naming to docker.io/library/monitoring-labs_prometheus             0.0s 
[+] Running 3/3                                                                
 ⠿ Network monitoring-labs_lab             Created                        0.1s 
 ⠿ Network monitoring-labs_default         Created                        0.1s
 ⠿ Container monitoring-labs_prometheus_1  Started                        0.7s
$ docker compose ps
NAME                           SERVICE             STATUS              PORTS
monitoring-labs_prometheus_1   prometheus          running

A partir deste ponto, as linhas que iniciarem por @prometheus $ devem ser executadas dentro do contêiner prometheus e as linhas que iniciarem por @host $ devem ser executadas na máquina host. Entre no contêiner com:

@host $ docker compose exec prometheus /bin/bash

Este contêiner é um contêiner debian:bullseye.

1. Instalação

Vá até esta para copiar o link de download. Faça o download dentro do contêiner prometheus, descompacte e entre na nova pasta. No exemplo a seguir usarei a versão 2.37.0.

@prometheus $ wget https://github.com/prometheus/prometheus/releases/download/v2.37.0/prometheus-2.37.0.linux-amd64.tar.gz
...
2022-09-06 00:48:02 (22.8 MB/s) - 'prometheus-2.37.0.linux-amd64.tar.gz' saved
@prometheus $ tar -xzvf prometheus-2.37.0.linux-amd64.tar.gz     
prometheus-2.37.0.linux-amd64/
prometheus-2.37.0.linux-amd64/consoles/
prometheus-2.37.0.linux-amd64/consoles/index.html.example
prometheus-2.37.0.linux-amd64/consoles/node-cpu.html
prometheus-2.37.0.linux-amd64/consoles/node-disk.html
prometheus-2.37.0.linux-amd64/consoles/node-overview.html
prometheus-2.37.0.linux-amd64/consoles/node.html
prometheus-2.37.0.linux-amd64/consoles/prometheus-overview.html
prometheus-2.37.0.linux-amd64/consoles/prometheus.html
prometheus-2.37.0.linux-amd64/console_libraries/
prometheus-2.37.0.linux-amd64/console_libraries/menu.lib
prometheus-2.37.0.linux-amd64/console_libraries/prom.lib
prometheus-2.37.0.linux-amd64/prometheus.yml
prometheus-2.37.0.linux-amd64/LICENSE
prometheus-2.37.0.linux-amd64/NOTICE
prometheus-2.37.0.linux-amd64/prometheus
prometheus-2.37.0.linux-amd64/promtool
@prometheus $ cd prometheus-2.37.0.linux-amd64
@prometheus $ ls -F
LICENSE  console_libraries/  prometheus*     promtool*
NOTICE   consoles/           prometheus.yml

Entre os arquivos extraídos temos o binário do prometheus, um binário utilitário chamado promtool e um exemplo de configuração. O exemplo de configuração junto com algumas explicações:

# Configurações globais
global:
  scrape_interval: 15s # Configura o tempo entre cada coleta para 15s. O padrão é a cada 1 minuto.
  evaluation_interval: 15s # Calcula regras a cada 15s. O padrão é a cada 1 minuto.
  # scrape_timeout é configurado para o padrão global (10s).

# Configurações do Alertmanager
alerting:
  alertmanagers:
    - static_configs:
        - targets:
          # - alertmanager:9093

# Carrega regras uma vez e periodicamente as calcula de acordo com o 'evaluation_interval' global.
rule_files:
  # - "first_rules.yml"
  # - "second_rules.yml"

# Uma configuração de coleta contendo exatamente um endpoint para coletar:
# Aqui está o próprio prometheus.
scrape_configs:
  # O nome do job é adicionado como uma label `job=<job_name>` para qualquer série temporal coletada desta configuração.
  - job_name: "prometheus"

    # metrics_path padrão é '/metrics'
    # scheme padrão é 'http'.

    static_configs:
      - targets: ["localhost:9090"]

2. Iniciando

O prometheus é iniciado com o seguinte comando:

@prometheus $ ./prometheus --config.file=prometheus.yml

No host execute ./get-ip-for prometheus para pegar o ip do contêiner e acesse no seu navegador com a porta 9090. Você verá uma tela similar a esta:

Antes de utilizar a UI web, acesse o endereço http://<ip do prometheus>:9090/metrics para ver como são as métricas. Exemplos de algumas métricas:

# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 4.0051e-05
go_gc_duration_seconds{quantile="0.25"} 6.132e-05
go_gc_duration_seconds{quantile="0.5"} 9.129e-05
go_gc_duration_seconds{quantile="0.75"} 0.001359203
go_gc_duration_seconds{quantile="1"} 0.001720425
go_gc_duration_seconds_sum 0.005046295
go_gc_duration_seconds_count 10
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 35
# HELP go_memstats_alloc_bytes_total Total number of bytes allocated, even if freed.
# TYPE go_memstats_alloc_bytes_total counter
go_memstats_alloc_bytes_total 7.6876768e+07
# HELP prometheus_tsdb_tombstone_cleanup_seconds The time taken to recompact blocks to remove tombstones.
# TYPE prometheus_tsdb_tombstone_cleanup_seconds histogram
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.005"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.01"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.025"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.05"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.1"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.25"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="0.5"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="1"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="2.5"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="5"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="10"} 0
prometheus_tsdb_tombstone_cleanup_seconds_bucket{le="+Inf"} 0
prometheus_tsdb_tombstone_cleanup_seconds_sum 0
prometheus_tsdb_tombstone_cleanup_seconds_count 0

Cada métrica inicia com duas linhas # HELP <nome> e # TYPE <nome>. A linha # HELP diz o que é esta métrica e # TYPE diz qual o tipo dela. O prometheus suporta quatro tipos de métricas, contadores, medidores, histogramas e sumários. Mais informações sobre cada tipo de métrica podem ser encontrados aqui. As próximas linhas contém o nome da métrica, labels entre {} e o valor da métrica. Cada linha é uma série. Cada série pode ter várias labels separadas por ,, ou nenhuma. No caso de não haverem labels, também não há {}.

Na UI web temos os menus alertas, gráfico, status e ajuda. Dentro do menu status temos informação de build e runtime, status do TSDB, flags de linha de comando, configuração, regras, alvos e service discovery.

Na página gráfico podemos ver os valores das métricas e gerar gráficos simples. Esta página é muito útil para debugar métricas. Na barra ao lado da lupa você pode escrever expressões em PromQL para executá-las. No botão com um planeta, logo ao lado, é possível explorar as métricas que estão no prometheus.

Para filtrar as séries com code=200 podemos escrever prometheus_http_requests_total{code="200"} e para filtrar mais ainda podemos adicionar labels separadas por ,, como prometheus_http_requests_total{code="200",handler="/metrics"}. Mais informações sobre PromQL podem ser encontrados aqui.

Comandos e atalhos do bash para produtividade

Francilio Araújo — Fri, 26 Aug 2022 19:33:00 +0000

Se você trabalha com tecnologia é bem provável que você faça uso de um shell por boa parte do dia. Por padrão o shell de sistemas GNU/linux é o bash, ou alternativas como o dash. Para facilitar o uso e aumentar a produtividade do usuário o bash tem várias funções que podem ser desconhecidas por alguns de seus usuários. Neste texto irei listar comandos e atalhos úteis para o dia a dia.

Comandos

A shell guarda um histórico de comandos executados e permite reutilizar comandos ou partes dele.
A referência ao histórico é feita pelo caractere !. Pode-se inserir apenas uma palavra de um comando do histórico e realizar modificações.

Selecionando um item do histórico

Executando o comando history são exibidos os comandos executados com um número. Referencia-se este comando adicionando o número após o !. Por exemplo, na figura abaixo !221 seria o comando history:

Pode-se utilizar números negativos para fazer referências a comandos anteriores ao atual. Na imagem anterior o comando history poderia ser referenciado também como !-1 e !-2 seria o comando echo loren ipsum dolor sit amet. !-1 também pode ser escrito como !!. A referência também pode ser feita como uma busca. !foo referencia o comando mais recente que inicie com foo e !?bar? referencia o comando mais recente que contenha bar. Pode-se referenciar também o comando que está sendo digitado com !#.

Logo após a referência do comando pode ser adicionado um : para fazer referência a apenas alguns parâmetros ou palavras. !!:1 é o primeiro argumento do comando anterior, !!:0 é o comando, !!:$ é o último e !!:1-4 são os argumentos de 1 a 4. Nos casos anteriores, no lugar de !! poderia ser escrito só !. Também é possível utilizar !!:* para utilizar todos os argumentos (equivalente a !!:1-$) ou !!:3* para utilizar do terceiro até o último.

É possível realizar modificações na linha ou palavra selecionada. Para adicionar uma modificação basta adicionar um : e a modificação. Para realizar uma substituição utiliza-se s para modificar uma vez e gs para modificar todas ocorrências. Por exemplo, assuma que !! seja o comando echo Lorem ipsum dolor sit amet. Para substituir o Lorem por lorem utiliza-se !!:s/Lorem/lorem/. Também podemos utilizar ^Lorem^lorem^.

Em resumo:

Referência a um comando n no histórico = !n
Referência a um comando anterior = !-n
Referência ao comando anterior = !-1 = !!
Referência ao último comando cat = !cat
Referência ao último comando com arquivo.txt = !?arquivo.txt?
Referência ao comando sendo digitado = !#
Referência a um argumento n = :n
Referência a todos os argumentos = :*
Referência aos argumentos m até n = :m-n
Referência aos argumentos n até o último = :n*
Realizar uma substituição = :s/velho/novo/
Realizar todas substituições = :gs/velho/novo/
Realizar uma substituição no último comando = ^velho^novo^

Executando vários comandos

O comando fc permite abrir comandos do histórico em um editor de textos para que eles possam ser executados. Para editar o último comando make, utiliza-se fc -s make. Para editar os 3 últimos comandos, utiliza-se fc -3 -1. Para executar do comando 16 ao 20 no histórico, utiliza-se fc 16 20. fc -l também pode ser utilizado para mostrar os últimos comandos.

Em resumo:

Editar e executar o último comando make = fc -s make
Editar e executar os últimos 5 comandos = fc -5 -1
Editar e executar os comandos de 7 a 15 = fc 7 15
Listar os últimos comandos = fc -l

Atalhos

Ao digitar texto no prompt do bash é possível realizar alguns comandos de edição por meio da biblioteca GNU readline. Os atalhos podem ser configurados por meio de um arquivo. Mais detalhes sobre a configuração e atalhos padrão podem ser encontrados na página do man, na página da wikipédia, ou no manual do usuário.

Movimento

As teclas ⬅️, ➡️, Home e End já são conhecidas. Além delas você pode utilizar Ctrl + seta ou Alt + seta para mover o cursor por palavra.

Além destas opções, a biblioteca permite utilizar Ctrl + b e Alt + b para mover o cursor para a esquerda um caractere e uma palavra, respectivamente, Ctrl + f e Alt + f para mover para a direita, Ctrl + a para mover para o início da linha e Ctrl + e para mover para o final. Ctrl + l é utilizado para limpar a tela e Ctrl + Alt + l para limpar a tela e o scroll.

Poderíamos resumir desta forma:

⬅️ = Ctrl + b
➡️ = Ctrl + f
Ctrl + <- ou Alt + <- = Alt + b
Ctrl + -> ou Alt + -> = Alt + f
Home = Ctrl + a
End = Ctrl + e

Em teclados menores que exigem o uso da tecla Fn para acessar as teclas de seta, Home e End pode ser mais confortável utilizar os atalhos do readline.

Histórico de comandos

Utiliza-se comumente as teclas ⬆️ e ⬇️ para percorrer a lista de comandos no histórico e a tecla Enter para executá-los. Pode-se utilizar Ctrl + p, Ctrl + n e Ctrl + j para os mesmos fins. Para ir até o comando mais antigo do histórico utiliza-se Alt + < e Alt + > para o mais novo.

Se você frequentemente fica utilizando a seta ⬆️ para encontrar o comando, existem atalhos para realizar buscas no histórico. Ctrl + r é utilizado para buscar comandos mais antigos que o atual e Ctrl + s é utilizado para buscar comandos mais novos. Ao utilizar um destes atalhos o prompt vai mudar e você pode ir digitando o que deve ser buscado.

Para reutilizar o primeiro argumento do comando anterior utiliza-se Ctrl + Alt + y. Pode-se selecionar outro argumento teclando a tecla Esc + número e Ctrl + Alt + y. Para o último argumento utiliza-se Alt + . ou Alt + _. Por exemplo, assuma que o comando anterior seja echo Lorem ipsum dolor sit amet. Ao utilizar Ctrl + Alt + y a palavra Lorem seria inserida, Esc + 3 a palavra dolor e Alt + . a palavra amet.

Ao executar vários comandos sucessivos repetidas vezes, no lugar de executar o primeiro com Enter ou Ctrl + j, você pode utilizar Ctrl + o e já será inserido o próximo comando do histórico.

Resumo:

⬆️ = Ctrl + p
⬇️ = Ctrl + n
Enter = Ctrl + j
início do histórico = Alt + <
fim do histórico = Alt + >
busca "acima" = Ctrl + r
busca "abaixo" = Ctrl + s
Inserir o primeiro argumento do comando anterior = Ctrl + Alt + y
Inserir o n-ésimo argumento = Esc + n e após Ctrl + Alt + y
Inserir o último argumento = Alt + .
Executar um comando do histórico e inserir o próximo = Ctrl + o

Edição da linha

As teclas <- Backspace e Delete já são conhecidas. No lugar da tecla <- Backspace pode-se utilizar Ctrl + ?. No lugar da tecla Delete pode-se utilizar Ctrl + d.

Para trocar duas palavras de lugar, utiliza-se Alt + t. Utiliza-se Alt + u e Alt + l para transformar a palavra em maiúsculas e minúsculas, respectivamente. Alt + c transforma a letra sob o cursor para maiúscula e todas as outras da palavra em minúscula.

Em resumo:

<- Backspace = Ctrl + ?
Delete = Ctrl + d
Transformar palavra em maiúsculas = Alt + u
Transformar palavra em minúsculas = Alt + l
Capitalizar letra na palavra = Alt + c

Recortar e Colar

Ctrl + w e Alt + d são utilizados para recortar do cursor para o início e fim da palavra, respectivamente. Ctrl + y é utilizado para colar texto recortado. Ctrl + u e Ctrl + k são utilizados para recortar do cursor para o início e fim da linha, respectivamente.

Em resumo:

Recortar do cursor pro início da linha = Ctrl + u
Recortar do cursor pro início da palavra = Ctrl + w
Recortar do cursor pro fim da palavra = Alt + d
Recortar do cursor pro fim da linha = Ctrl + k
Colar texto recortado = Ctrl + y

Compleção

Utiliza-se Tab para completar a palavra até o cursor. Para exibir todas as possíveis compleções utiliza-se Alt + ?.

Em resumo:

Completar = Tab
Mostrar todas possibilidades para completar = Alt + ?

Outros

Abortar um comando sem executar = Ctrl + g
Desfazer edição = Ctrl + _
Busca por caractere até final da linha = Ctrl + ]
Busca por caractere até início da linha = Ctrl + Alt + ]