- permissões de arquivo,
- número de links,
- nome do proprietário,
- grupo do proprietário,
- tamanho do arquivo,
- hora da última modificação,
- nome do arquivo/diretório

As permissões de arquivo são exibidas da seguinte forma:

- o primeiro caractere é `-` ou `l` ou `d`, `d` indica um diretório, `-` representa um arquivo, `l` é um link simbólico (ou link suave) — um tipo especial de arquivo
- três conjuntos de caracteres, três vezes, indicando permissões para proprietário, grupo e outros:
  - `r` = legível
  - `w` = gravável
  - `x` = executável

No seu exemplo `-rwxrw-r--`, isso significa que a linha exibida é:

- um arquivo regular (exibido como `-`)
- legível, gravável e executável pelo proprietário (`rwx`)
- legível, gravável, mas não executável pelo grupo (`rw-`)
- legível, mas não gravável ou executável por outros (`r--`)

Recursos úteis:

- [O que significam os campos na saída de ls -al? (original)](https://unix.stackexchange.com/questions/103114/what-do-the-fields-in-ls-al-output-mean)

</details>

<details>
<summary><b>Como obter uma lista de usuários logados?</b></summary><br>

Para um resumo dos usuários logados, incluindo cada login de um nome de usuário, os terminais aos quais os usuários estão conectados, a data/hora em que fizeram login e, possivelmente, o computador a partir do qual estão fazendo a conexão, digite:```bash
# It uses /var/run/utmp and /var/log/wtmp files to get the details.
who

Quando você executa o comando acima, obtém a seguinte saída:```bash
[1] 2203

Quando você executa um job em segundo plano, ele fornece um PID do job. Você pode matar o job em execução em segundo plano usando o seguinte comando:```bash
kill PID

Se você tiver vários jobs rodando em segundo plano, você pode trazer qualquer job para o primeiro plano usando:```bash
fg %#

Para alterar todos os arquivos, por exemplo, para **644** (`-rw-r--r--`):```bash
find /opt/data -type f -exec chmod 644 {} \;

Isso mostrará cada comando e seus argumentos, que são executados ao iniciar esse shell.

Também é muito útil mostrar os valores da variável `PATH`:```bash
echo $PATH

a maioria dos comandos deve começar a funcionar - e então você pode editar `~/.bash_profile` em vez de `~/.bashrc` e corrigir o que está redefinindo `PATH` lá. Os valores padrão da variável `PATH` para **root** e outros usuários estão no arquivo `/etc/profile`.

Recurso útil:

- [Como adicionar corretamente um caminho ao PATH?](https://unix.stackexchange.com/questions/26047/how-to-correctly-add-a-path-to-path)

</details>

<details>
<summary><b>Você digita <code>CTRL + C</code> mas seu script ainda está rodando. Como pará-lo?</b></summary><br>

Na maioria dos casos, você pode parar um script em execução usando a combinação de teclas `CTRL + C`. Isso envia um sinal de interrupção (SIGINT) para o script, que encerra sua execução. Se isso não funcionar e o script ainda estiver rodando, você pode tentar usar a combinação `CTRL + \`, que envia um sinal de saída (SIGQUIT) para o script, podendo terminá-lo imediatamente.

Alternativamente, se você estiver usando um terminal ou interface de linha de comando, pode tentar usar o comando `kill` para enviar um sinal ao processo do script. Você pode encontrar o ID do processo (PID) do script usando os comandos `ps` ou `top`, e depois usar `kill` com o PID para parar o script.

Em alguns casos, pode ser necessário usar o comando `kill -9` para forçar a parada do script, pois o comando kill normal pode não funcionar se o script estiver travado ou não responder. A opção `-9` envia um sinal SIGKILL, que força o processo a parar imediatamente.
</details>

<details>
<summary><b>O que é o comando <code>grep</code>? Como combinar múltiplas strings na mesma linha?</b></summary><br>

Os utilitários `grep` são uma família de ferramentas Unix, incluindo `egrep` e `fgrep`.

`grep` pesquisa padrões em arquivos. Se você está procurando por um padrão específico na saída de outro comando, o `grep` destaca as linhas relevantes. Use este comando grep para pesquisar arquivos de log, processos específicos e mais.

Para combinar múltiplas strings:```bash
grep -E "string1|string2" filename

Se um dos comandos falhar, então todos os outros comandos seguintes não serão executados.

Se você quiser executar todos os comandos independentemente de os anteriores terem falhado ou não, separe-os com ponto e vírgula:```bash
cd /my_folder; rm *.jar; svn co path to repo; mvn compile package install

Recursos úteis:

- [Executar e combinar vários comandos Linux em uma linha (original)](https://stackoverflow.com/questions/13077241/execute-combine-multiple-linux-commands-in-one-line)

</details>

<details>
<summary><b>Qual representação simbólica você pode passar para <code>chmod</code> para dar a todos os usuários acesso de execução a um arquivo sem afetar outras permissões?</b></summary><br>```bash
chmod a+x /path/to/file

- `-a`, `--archive` - modo de arquivo
- `--delete` - eliminar ficheiros extra dos diretórios de destino
- `-v`, `--verbose` - modo verboso (aumentar verbosidade)
- `--progress` - mostrar progresso durante a transferência

Recursos úteis:

- [Como posso sincronizar dois diretórios locais? (original](https://unix.stackexchange.com/questions/392536/how-can-i-sync-two-local-directories)
- [Sincronizando pastas com rsync](https://www.jveweb.net/en/archives/2010/11/synchronizing-folders-with-rsync.html)

</details>

<details>
<summary><b>Muitas tarefas básicas de manutenção exigem que você edite arquivos de configuração. Explique maneiras de desfazer as alterações feitas.</b></summary><br>

- backup manual de um ficheiro antes de editar (com expansão de chaves como esta: `cp filename{,.orig}`)
- cópia manual da estrutura de diretórios onde o ficheiro está armazenado (ex.: `cp`, `rsync` ou `tar`)
- faça um backup do ficheiro original no seu editor (ex.: defina regras no ficheiro de configuração do seu editor)
- a melhor solução é usar `git` (ou qualquer outro controle de versão) para manter o controle dos ficheiros de configuração (ex.: `etckeeper` para o diretório `/etc`)

Recursos úteis:

- [Fazer backup de ficheiro com .bak antes da extensão do nome do ficheiro](https://unix.stackexchange.com/questions/66376/backup-file-with-bak-before-filename-extension)
- [É uma boa ideia usar git para controle de versão de ficheiros de configuração?](https://superuser.com/questions/1037211/is-it-a-good-idea-to-use-git-for-configuration-file-version-controlling)

</details>

<details>
<summary><b>Você precisa encontrar todos os ficheiros maiores que 20MB. Como você faz?</b></summary><br>```bash
find / -type f -size +20M

Recursos úteis:

- [Número da porta do ping](https://networkengineering.stackexchange.com/questions/42463/ping-port-number)
- [É possível pingar um endereço:porta?](https://superuser.com/questions/769541/is-it-possible-to-ping-an-addressport)

</details>

<details>
<summary><b>O Servidor A não consegue se comunicar com o Servidor B. Descreva possíveis razões em alguns passos.</b></summary><br>

Para solucionar problemas de comunicação entre servidores, é melhor seguir idealmente a pilha TCP/IP:

1. **Camada de Aplicação**: os serviços estão ativos e em execução em ambos os servidores? Eles estão configurados corretamente (por exemplo, vincular o IP e a porta corretos)? Os logs de aplicação e sistema mostram erros significativos?

2. **Camada de Transporte**: as portas usadas pela aplicação estão abertas (tente telnet!)? É possível pingar o servidor?

3. **Camada de Rede**: existe um firewall na rede ou no SO configurado corretamente? A pilha IP está configurada corretamente (IP, rotas, DNS, etc.)? Switches e roteadores estão funcionando (verifique a tabela ARP!)?

4. **Camada Física**: os servidores estão conectados a uma rede? Pacotes estão sendo perdidos?

</details>

<details>
<summary><b>Por que os nomes de host não resolvem no seu servidor? Corrija este problema. ***</b></summary><br>

A ser concluído.

</details>

<details>
<summary><b>Como resolver o nome de domínio (usando DNS externo) com CLI? IPs podem ser resolvidos para nomes de domínio?</b></summary><br>

Exemplos para resolver endereço IP para nome de domínio:```bash
# with host command:
host domain.com 8.8.8.8

# with dig command:
dig @9.9.9.9 google.com

# with nslookup command:
nslookup domain.com 8.8.8.8

</details>

<details>
<summary><b>Por que você deve evitar o <code>telnet</code> para administrar um sistema remotamente?</b></summary><br>

Os sistemas operacionais modernos desativaram todos os serviços potencialmente inseguros por padrão. Por outro lado, alguns fornecedores de dispositivos de rede ainda permitem estabelecer comunicação usando o protocolo telnet.

**Telnet** usa o método mais inseguro para comunicação. Ele envia dados pela rede em formato de texto simples e qualquer pessoa pode facilmente descobrir a senha usando uma ferramenta de rede.

No caso do **Telnet**, isso inclui a passagem de credenciais de login em texto simples, o que significa que qualquer pessoa executando um sniffer na sua rede pode encontrar as informações necessárias para assumir o controle de um dispositivo em poucos segundos, bisbilhotando uma sessão de login **Telnet**.

Recursos úteis:

- [Telnet e SSH como alternativa segura](https://www.ssh.com/ssh/telnet)
- [Como telnet para um endereço IP em uma porta específica?](https://superuser.com/questions/339107/how-to-telnet-to-an-ip-address-on-a-specific-port)

</details>

<details>
<summary><b>Qual é a diferença entre <code>wget</code> e <code>curl</code>?</b></summary><br>

As principais diferenças são: o ponto forte do `wget` em comparação com o `curl` é sua capacidade de baixar recursivamente. O `wget` é apenas linha de comando. O `curl` suporta FTP, FTPS, HTTP, HTTPS, SCP, SFTP, TFTP, TELNET, DICT, LDAP, LDAPS, FILE, POP3, IMAP, SMTP, RTMP e RTSP.

Recursos úteis:

- [Qual é a diferença entre curl e wget? (original)](https://unix.stackexchange.com/questions/47434/what-is-the-difference-between-curl-and-wget)

</details>

<details>
<summary><b>O que é SSH e como funciona?</b></summary><br>

**SSH** significa **Secure Shell**. É um protocolo que permite a você ir de um servidor "A" para uma sessão shell em um servidor "B". Ele permite interagir com seu servidor "B".

Para que uma conexão **SSH** seja estabelecida, a máquina remota (servidor A) deve estar executando um software chamado daemon **SSH** e o computador do usuário (servidor B) deve ter um cliente **SSH**.

O daemon **SSH** e o cliente **SSH** ouvem conexões em uma porta de rede específica (porta 22 padrão), autenticam solicitações de conexão e iniciam o ambiente apropriado se o usuário fornecer as credenciais corretas.

Recursos úteis:

- [Entendendo o processo de criptografia e conexão SSH](https://www.digitalocean.com/community/tutorials/understanding-the-ssh-encryption-and-connection-process)

</details>

<details>
<summary><b>A maioria dos tutoriais sugere usar autenticação por chave SSH em vez de autenticação por senha. Por que é considerada mais segura?</b></summary><br>

Uma **chave SSH** é uma credencial de acesso no protocolo SSH. Sua função é semelhante à de nomes de usuário e senhas, mas as chaves são usadas principalmente para processos automatizados e para implementar single sign-on por administradores de sistema e usuários avançados.

Em vez de exigir a senha do usuário, é possível confirmar a identidade do cliente usando algoritmos de criptografia assimétrica, com chaves pública e privada.

Se seu serviço SSH permitir apenas autenticação por chave pública, um invasor precisará de uma cópia de uma chave privada correspondente a uma chave pública armazenada no servidor.

Se seu serviço SSH permitir autenticação baseada em senha, então seu servidor SSH conectado à Internet será bombardeado dia e noite por botnets tentando adivinhar nomes de usuário e senhas. O botnet não precisa de informações; ele pode apenas tentar nomes populares e senhas populares. Além de outras coisas, isso entope seus logs.

Recursos úteis:

- [Autenticação Baseada em Chave (Autenticação por Chave Pública)](http://www.crypto-it.net/eng/tools/key-based-authentication.html)
- [Senha SSH vs. autenticação por chave](https://security.stackexchange.com/questions/33381/ssh-password-vs-key-authentication)

</details>

<details>
<summary><b>O que é um filtro de pacotes e como funciona?</b></summary><br>

**Filtragem de pacotes** é uma técnica de firewall usada para controlar o acesso à rede monitorando pacotes de saída e entrada e permitindo que eles passem ou parem com base nos endereços IP de origem e destino, protocolos e portas.

A filtragem de pacotes é apropriada onde há requisitos de segurança modestos. As redes internas (privadas) de muitas organizações não são altamente segmentadas. Firewalls altamente sofisticados não são necessários para isolar uma parte da organização de outra.

No entanto, é prudente fornecer algum tipo de proteção da rede de produção de uma rede de laboratório ou experimental. Um dispositivo de filtragem de pacotes é uma medida muito apropriada para fornecer isolamento de uma sub-rede de outra.

Operando na camada de rede e na camada de transporte da pilha de protocolos TCP/IP, cada pacote é examinado à medida que entra na pilha de protocolos. Os cabeçalhos de rede e transporte são examinados de perto para as seguintes informações:

- **protocolo (cabeçalho IP, camada de rede)** - no cabeçalho IP, o byte 9 (lembre-se de que a contagem de bytes começa em zero) identifica o protocolo do pacote. A maioria dos dispositivos de filtro tem a capacidade de diferenciar entre TCP, UDP e ICMP.
- **endereço de origem (cabeçalho IP, camada de rede)** - o endereço de origem é o endereço IP de 32 bits do host que criou o pacote.
- **endereço de destino (cabeçalho IP, camada de rede)** - o endereço de destino é o endereço IP de 32 bits do host para o qual o pacote é destinado.
- **porta de origem (cabeçalho TCP ou UDP, camada de transporte)** - cada extremidade de uma conexão de rede TCP ou UDP está vinculada a uma porta. As portas TCP são separadas e distintas das portas UDP. As portas numeradas abaixo de 1024 são reservadas – elas têm um uso especificamente definido. As portas numeradas acima de 1024 (inclusive) são conhecidas como portas efêmeras. Elas podem ser usadas como o fornecedor escolher. Para uma lista de portas "bem conhecidas", consulte RFP1700. A porta de origem é um número de porta efêmera pseudoaleatório. Portanto, muitas vezes não é muito útil filtrar pela porta de origem.
- **porta de destino (cabeçalho TCP ou UDP, camada de transporte)** - o número da porta de destino indica uma porta para a qual o pacote é enviado. Cada serviço no host de destino escuta em uma porta. Algumas portas bem conhecidas que podem ser filtradas são 20/TCP e 21/TCP - conexão/dados ftp, 23/TCP - telnet, 80/TCP - http e 53/TCP - transferências de zona DNS.
- **status da conexão (cabeçalho TCP, camada de transporte)** - o status da conexão informa se o pacote é o primeiro pacote da sessão de rede. O bit ACK no cabeçalho TCP é definido como "falso" ou 0 se este for o primeiro pacote da sessão. É simples impedir que um host estabeleça uma conexão, rejeitando ou descartando qualquer pacote que tenha o bit ACK definido como "falso" ou 0.

Recursos úteis:

- [Construindo Firewalls de Internet - Filtragem de Pacotes](http://web.deu.edu.tr/static/oreily/networking/firewall/ch06_01.htm)

</details>

<details>
<summary><b>Quais são as vantagens de usar um servidor proxy reverso?</b></summary><br>

**Ocultar a topologia e as características de seus servidores back-end**

O **servidor proxy reverso** pode ocultar a presença e as características do servidor de origem. Ele atua como um intermediário entre a nuvem da internet e o servidor web. É bom por questões de segurança, especialmente quando você está usando serviços de hospedagem web.

**Permite manutenção transparente de servidores backend**

As alterações que você fizer nos servidores executados atrás de um proxy reverso serão completamente transparentes para seus usuários finais.

**Balanceamento de carga**

O proxy reverso aplicará um algoritmo de balanceamento de carga como round robin, round robin ponderado, menos conexões, menos conexões ponderadas ou aleatório, para distribuir a carga entre os servidores no cluster.

Quando um servidor cai, o sistema automaticamente faz failover para o próximo servidor ativo e os usuários podem continuar com suas atividades de transferência segura de arquivos.

**Offloading/terminação SSL**

Lida com conexões HTTPS de entrada, descriptografando as solicitações e passando solicitações não criptografadas para os servidores web.

**Mascaramento de IP**

Usando um único IP, mas URLs diferentes para rotear para diferentes servidores back-end.

Recursos úteis:

- [Os Benefícios de um Proxy Reverso](https://dzone.com/articles/benefits-reverse-proxy)

</details>

<details>
<summary><b>Qual é a diferença entre um roteador e um gateway? O que é o gateway padrão?</b></summary><br>

**Roteador** descreve a função técnica geral (encaminhamento de camada 3) ou um dispositivo de hardware destinado a esse propósito, enquanto gateway descreve a função para o segmento local (fornecendo conectividade para outro lugar). Você também poderia afirmar que "_você configura um roteador como gateway_". Outro termo é hop, que descreve o encaminhamento entre sub-redes.

O termo **gateway padrão** é usado para se referir ao roteador em sua LAN que tem a responsabilidade de ser o primeiro ponto de contato para o tráfego destinado a computadores fora da LAN.

É apenas uma questão de perspectiva; o dispositivo é o mesmo.

Recursos úteis:

- [Diferença entre roteador e gateway (original)](https://networkengineering.stackexchange.com/questions/51426/difference-between-router-and-gateway)

</details>

<details>
<summary><b>Explique a função de cada um dos seguintes registros DNS: SOA, PTR, A, MX e CNAME.</b></summary><br>

**Registros DNS** são basicamente arquivos de mapeamento que informam ao servidor DNS qual endereço IP cada domínio está associado e como lidar com solicitações enviadas a cada domínio. Algumas sintaxes de **registros DNS** comumente usadas em quase todas as configurações de registro DNS são `A`, `AAAA`, `CNAME`, `MX`, `PTR`, `NS`, `SOA`, `SRV`, `TXT` e `NAPTR`.

- **SOA** - Start Of Authority (Início de Autoridade)
- **A** - Registros de Mapeamento de Endereço
- **AAAA** - Registros de Endereço IPv6
- **CNAME** - Registros de Nome Canônico
- **MX** - Registro de troca de correio
- **NS** - Registros de Servidor de Nomes
- **PTR** - Registros de Ponteiro de Consulta Reversa

Recursos úteis:

- [Lista de tipos de registros DNS](https://en.wikipedia.org/wiki/List_of_DNS_record_types)

</details>

<details>
<summary><b>Por que os endereços MAC não poderiam ser usados em vez de IPv4/6 para rede?</b></summary><br>

O modelo **OSI** explica por que não faz sentido tomar decisões de roteamento, um conceito de **camada 3**, com base em um mecanismo físico, **camada 2**.

A rede moderna é dividida em muitas camadas diferentes para realizar sua comunicação de ponta a ponta. Sua placa de rede (o que é endereçado pelo endereço MAC - endereço físico) precisa ser responsável apenas pela comunicação com pares em sua rede física.

A comunicação que você pode realizar com seu endereço **MAC** será limitada a outros dispositivos que residem em contato físico com sua máquina. Na internet, por exemplo, você não está fisicamente conectado a cada máquina. É por isso que usamos o mecanismo **TCP/IP** (um endereço lógico de **camada 3**) quando precisamos nos comunicar com uma máquina à qual não estamos fisicamente conectados.

**IP** é um esquema de numeração arbitrário imposto de forma hierárquica a um grupo de computadores para distingui-los logicamente como um grupo (isso é o que é uma sub-rede). O envio de mensagens entre esses grupos é feito por tabelas de roteamento, elas próprias divididas em vários níveis para que não tenhamos que acompanhar cada sub-rede individual.

Também é bastante fácil relacionar isso a outro par de sistemas. Você tem um Número de Identificação emitido pelo Estado; por que você precisaria de um endereço postal se esse número de identificação já é único para você? Você precisa do endereço postal porque é um sistema arbitrário que descreve onde o destino único para comunicações para você deve ir.

Por outro lado, a distribuição de endereços **MAC** pela rede é aleatória e completamente não relacionada à topologia. O agrupamento de rotas seria impossível; todo roteador precisaria manter o controle de rotas para cada dispositivo que encaminha tráfego através dele. Isso é o que os switches de **camada 2** fazem, e isso não escala bem além de um certo número de hosts.

Recursos úteis:

- [Por que os endereços MAC não poderiam ser usados em vez de IPv4|6 para rede? (original)](https://serverfault.com/questions/410626/why-couldnt-mac-addresses-be-used-instead-of-ipv46-for-networking)

</details>

<details>
<summary><b>Qual é a menor máscara de sub-rede IPv4 que pode ser aplicada a uma rede contendo até 30 dispositivos?</b></summary><br>

Se você tem uma VLAN `/24` padrão para usuários finais, uma `/30` para links ponto a ponto, ou algo intermediário, a sub-rede que deve conter até 30 dispositivos resulta em uma `/27` - ou uma máscara de sub-rede de `255.255.255.224`.

Recursos úteis:

- [Como calcular o prefixo, rede, sub-rede e números de host?](https://networkengineering.stackexchange.com/questions/7106/how-do-you-calculate-the-prefix-network-subnet-and-host-numbers)
- [A barra após um endereço IP - Notação CIDR](https://networkengineering.stackexchange.com/questions/3697/the-slash-after-an-ip-address-cidr-notation)
- [Por que existem 3 faixas de endereços IPv4 privados?](https://networkengineering.stackexchange.com/questions/32119/why-are-there-3-ranges-of-private-ipv4-addresses)
- [Calculadora IP](http://jodies.de/ipcalc)

</details>

<details>
<summary><b>Quais são alguns códigos de status HTTP comuns?</b></summary><br>

- **1xx** - Respostas informativas - comunica informações de nível de protocolo de transferência
- **2xx** - Sucesso - indica que a solicitação do cliente foi aceita com sucesso
- **3xx** - Redirecionamento - indica que o cliente deve tomar alguma ação adicional para completar sua solicitação
- **4xx** - Erro do lado do cliente - esta categoria de códigos de status de erro aponta o dedo para os clientes
- **5xx** - Erro do lado do servidor - o servidor assume a responsabilidade por esses códigos de status de erro

Recursos úteis:

- [Códigos de Status HTTP](https://httpstatuses.com/)

</details>

###### Perguntas de DevOps (5)

<details>
<summary><b>O que é DevOps? O que é mais importante para o sucesso de qualquer comunidade DevOps: como as pessoas se comunicam ou as ferramentas que você escolhe para implantar? ***</b></summary><br>

**DevOps** é uma equipe coesa que se envolve em tarefas de Desenvolvimento e Operações, ou são equipes individuais de Operações e Desenvolvimento que trabalham muito próximas. É mais uma "forma" de trabalhar colaborativamente com outros departamentos para alcançar objetivos comuns.

</details>

<details>
<summary><b>O que é um controle de versão? Suas mensagens de commit são bonitas?</b></summary><br>

É um sistema que registra alterações em um arquivo ou conjunto de arquivos ao longo do tempo para que você possa recuperar versões específicas posteriormente. Os sistemas de controle de versão consistem em um repositório central compartilhado onde os colegas de equipe podem confirmar alterações em um arquivo ou conjunto de arquivos. Então você pode mencionar os usos do controle de versão.

O controle de versão permite que você:

- reverta arquivos para um estado anterior
- reverta o projeto inteiro para um estado anterior
- compare mudanças ao longo do tempo
- veja quem modificou algo pela última vez que pode estar causando um problema
- veja quem introduziu um problema e quando

As sete regras de uma ótima mensagem de commit:

- separe o assunto do corpo com uma linha em branco
- limite a linha de assunto a 50 caracteres
- capitalize a linha de assunto
- não termine a linha de assunto com um ponto
- use o modo imperativo na linha de assunto
- quebre o corpo em 72 caracteres
- use o corpo para explicar o quê e porquê vs. como

Recursos úteis:

- [Começando - Sobre Controle de Versão (original)](https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control)

</details>

<details>
<summary><b>Explique alguns comandos básicos do <code>git</code>.</b></summary><br>

- `git init` - cria um novo repositório local
- `git commit -m "mensagem"` - confirma mudanças no head
- `git status` - lista os arquivos que você adicionou com `git add` e também confirma quaisquer arquivos que você alterou desde então
- `git push origin master` - envia mudanças para o branch master do seu repositório remoto

</details>

<details>
<summary><b>Explique um pipeline simples de Integração Contínua.</b></summary><br>

- clonar repositório
- estágio de implantação (QA)
- ambiente de teste (QA)
- estágio de implantação (PROD)

</details>

<details>
<summary><b>Explique alguns comandos básicos do <code>docker</code>.</b></summary><br>

- `docker ps` - mostra contêineres em execução
- `docker ps -a` - mostra todos os contêineres
- `docker images` - mostra imagens docker
- `docker logs <id-do-contêiner|nome-do-contêiner>` - obtém logs do contêiner
- `docker network ls` - mostra todas as redes docker
- `docker volumes ls` - mostra todos os volumes docker
- `docker exec -it <id-do-contêiner|nome-do-contêiner> bash` - executa bash no contêiner com shell interativo

</details>

###### Perguntas de Segurança Cibernética (1)

<details>
<summary><b>O que é uma Configuração Incorreta de Segurança?</b></summary><br>

**Configuração incorreta de segurança** é uma vulnerabilidade quando um dispositivo/aplicação/rede é configurado de uma forma que pode ser explorada por um invasor para tirar proveito dela. Isso pode ser tão simples quanto deixar o nome de usuário/senha padrão inalterados ou muito simples para contas de dispositivos, etc.

</details>

### :diamond_shape_with_a_dot_inside: <a name="regular-sysadmin">Sysadmin Regular</a>

###### Perguntas sobre Sistema (60)

<details>
<summary><b>Conte-me sobre sua experiência com ambientes de produção? ***</b></summary><br>

A ser preenchido.

</details>

<details>
<summary><b>Qual distribuição você escolheria para executar um servidor web importante? ***</b></summary><br>

A ser preenchido.

</details>

<details>
<summary><b>Explique em alguns pontos o processo de inicialização do sistema Linux.</b></summary><br>

**BIOS**: O nome completo do BIOS é Basic Input or Output System (Sistema Básico de Entrada ou Saída) que realiza verificações de integridade e irá procurar, carregar e então executar o bootloader.

**Bootloader**: Como as fases anteriores não são específicas do sistema operacional, o processo de inicialização baseado em BIOS para arquiteturas x86 e x86-64 é considerado iniciado quando o código do master boot record (MBR) é executado em modo real e o bootloader de primeiro estágio é carregado. Em sistemas UEFI, uma carga útil, como o kernel Linux, pode ser executada diretamente. Portanto, nenhum bootloader é necessário. Alguns bootloaders populares: **GRUB**, **Syslinux/Isolinux** ou **Lilo**.

**Kernel**: O kernel no Linux lida com todos os processos do sistema operacional, como gerenciamento de memória, agendamento de tarefas, I/O, comunicação entre processos e controle geral do sistema. Ele é carregado em duas etapas - na primeira etapa, o kernel (como um arquivo de imagem compactado) é carregado na memória e descompactado, e algumas funções fundamentais, como gerenciamento básico de memória, são configuradas.

**Init**: É o pai de todos os processos no sistema; é executado pelo kernel e é responsável por iniciar todos os outros processos.

- `SysV init` - o trabalho do init é "fazer tudo funcionar como deveria uma vez que o kernel esteja totalmente em execução". Essencialmente, ele estabelece e opera todo o espaço do usuário. Isso inclui verificar e montar sistemas de arquivos, iniciar serviços de usuário necessários e, finalmente, mudar para um ambiente de usuário quando a inicialização do sistema é concluída.
- `systemd` - os desenvolvedores do systemd tinham como objetivo substituir o sistema init do Linux herdado do Unix System V. Como o init, o systemd é um daemon que gerencia outros daemons. Todos os daemons, incluindo o systemd, são processos em segundo plano. O systemd é o primeiro daemon a iniciar (durante a inicialização) e o último daemon a terminar (durante o desligamento).
- `runinit` - runinit é um esquema init para sistemas operacionais tipo Unix que inicializa, supervisiona e encerra processos em todo o sistema operacional. É uma reimplementação do kit de ferramentas de supervisão de processos daemontools que funciona nos sistemas operacionais Linux, Mac OS X, \*BSD e Solaris.

Recursos úteis:

- [Analisando o processo de inicialização do Linux](https://opensource.com/article/18/1/analyzing-linux-boot-process)
- [Processo de inicialização do Systemd: um olhar detalhado no Linux](https://linoxide.com/linux-how-to/systemd-boot-process/)

</details>

<details>
<summary><b>Como e por que os daemons do Linux reduzem privilégios? Por que alguns daemons precisam de permissões root para iniciar? Explique. ***</b></summary>

A ser preenchido.

</details>

<details>
<summary><b>Por que uma carga de 1,00 não é ideal em uma máquina single-core?</b></summary><br>O problema com uma carga de 1,00 é que não há margem de manobra. Na prática, muitos administradores de sistema traçam um limite em 0,70.

**Regra de ouro "Precisa investigar":** 0,70. Se sua média de carga permanecer acima de > 0,70, é hora de investigar antes que as coisas piorem.

**Regra de ouro "Conserte isso agora":** 1,00. Se sua média de carga permanecer acima de 1,00, encontre o problema e conserte-o imediatamente. Caso contrário, você será acordado no meio da noite, e não será divertido.

**Regra de ouro:** 5,0. Se sua média de carga estiver acima de 5,00, você pode estar com sérios problemas; sua máquina pode estar travando ou ficando muito lenta, e isso (inexplicavelmente) acontecerá no pior momento possível, como no meio da noite ou quando você estiver apresentando em uma conferência. Não deixe chegar a esse ponto.

Recursos úteis:

- [Proper way of interpreting system load on a 4 core 8 thread processor](https://serverfault.com/questions/618130/proper-way-of-interpreting-system-load-on-a-4-core-8-thread-processor)
- [Understanding Linux CPU Load - when should you be worried?](http://blog.scoutapp.com/articles/2009/07/31/understanding-load-averages)

</details>

<details>
<summary><b>O que significa quando o usuário efetivo é root, mas o ID de usuário real ainda é o seu nome?</b></summary><br>

O **ID de usuário real** é quem você realmente é (o usuário que possui o processo), e o **ID de usuário efetivo** é o que o sistema operacional verifica para decidir se você tem permissão para fazer algo (na maioria das vezes, há algumas exceções).

Quando você faz login, o shell de login define tanto o **ID de usuário real quanto o efetivo** para o mesmo valor (seu **ID de usuário real**) conforme fornecido pelo arquivo de senhas.

Se, por exemplo, você executa setuid, e além de executar como outro usuário (por exemplo, **root**), o programa setuid também deve fazer algo em seu nome.

Após executar setuid, ele terá seu **ID real** (já que você é o proprietário do processo) e o ID de usuário efetivo do proprietário do arquivo (por exemplo, **root**) já que é setuid.

Vamos usar o caso do `passwd`:```bash
-rwsr-xr-x 1 root root 45396 may 25  2012 /usr/bin/passwd

É muito útil, pois trunca o ficheiro sem interromper os processos.

Recursos úteis:

- [How to Use logrotate to Manage Log Files](https://www.linode.com/docs/uptime/logs/use-logrotate-to-manage-log-files/)
- [System logging](https://www.ibm.com/developerworks/library/l-lpic1-108-2/index.html)

</details>

<details>
<summary><b>Como é que o kernel do Linux cria, gere e elimina os processos no sistema? ***</b></summary><br>

Por preencher.

Recursos úteis:

- [Linux Processes](https://www.tldp.org/LDP/tlk/kernel/processes.html)

</details>

<details>
<summary><b>Explique a informação selecionada que pode ver em <code>top</code> e <code>htop</code>. Como diagnosticar problemas de carga, tempo de utilizador elevado e falta de memória com estas ferramentas? ***</b></summary><br>

Por preencher.

Recursos úteis:

- [top explained visually](https://www.svennd.be/top-explained-visually/)
- [htop Explained Visually](https://codeahoy.com/2017/01/20/hhtop-explained-visually/)
- [Explanation of everything you can see in htop/top on Linux](https://peteris.rocks/blog/htop/)

</details>

<details>
<summary><b>Como reconheceria um processo que está a consumir muitos recursos? </b></summary><br>

`top` funciona razoavelmente bem, desde que olhe para os números certos.
- **M** Ordena pela utilização atual de memória residente
- **T** Ordena pela utilização total (ou cumulativa) de CPU
- **P** Ordena pela utilização atual de CPU (esta é a atualização predefinida)
- **?** Mostra um resumo de utilização para todos os comandos top

Esta é uma informação muito importante para obter quando se está a resolver problemas de lentidão de um processo informático e a tomar decisões sobre que processos matar/software desinstalar.

Recursos úteis:

- [How to find the process(es) which are hogging the machine](https://superuser.com/questions/326300/how-to-find-the-processes-which-are-hogging-the-machine)

</details>

<details>
<summary><b>Precisa de atualizar o serviço <code>ntpd</code> em 200 servidores. Qual é a melhor forma de atualizar todos para a versão mais recente?</b></summary><br>

Usando a abordagem **Infrastructure as a Code**, existem várias boas formas:

1. **Modelo de Gestão de Mudanças por Sincronização de Configuração**:

Existem Ferramentas de Gestão de Configuração (Ansible, Chef, Puppet, Saltstack, ...), que podem ser utilizadas para atualizar automaticamente o serviço `ntpd` em todos os servidores. Para manter os sistemas estáveis, os pacotes de sistema nos servidores são geralmente atualizados automaticamente apenas com atualizações de segurança. Versões maiores ou menores de pacotes são geralmente bloqueadas por versão nas definições de configuração para evitar má configuração do serviço. A mudança é então implementada alterando a versão do `ntpd` na definição de configuração.

Com esta abordagem, é importante ter cuidado ao implementar mudanças na infraestrutura em massa. O pipeline de implementação deve incluir testes unitários, de integração e de sistema, e eventualmente ser primeiramente implementado no ambiente de Staging para comprovar a configuração. Se os testes provarem a correção da configuração, a implementação deve ser feita através de um rollout incremental com capacidade de reverter em caso de erros ou falhas.

2. **Modelo de Servidores Imutáveis**:

No modelo de Servidor Imutável, a unidade completa (servidor, contentor) é substituída por uma nova imagem atualizada em vez de fazer alterações ao servidor em execução (isto elimina o desvio de configuração). Com esta abordagem, normalmente constrói-se a imagem do servidor com ferramentas como Packer ou Docker com Dockerfile. Esta imagem é então testada e implementada de forma semelhante à opção acima (1.), mas agora usando técnicas como Canary Release, que também tem capacidade de rollout incremental e reversão.

Recursos úteis:

- [Infrastructure as a Code - Chapter 8: Patterns for Updating and Changing Servers](http://shop.oreilly.com/product/0636920039297.do)

</details>

<details>
<summary><b>Como definir permanentemente o <code>$PATH</code> no Linux/Unix? Porque é que esta variável é tão importante? ***</b></summary>

Por preencher.

</details>

<details>
<summary><b>Quando o seu servidor está a arrancar, alguns erros aparecem na consola. Como examinar as mensagens de boot e onde estão armazenadas?</b></summary><br>

A sua consola tem dois tipos de mensagens:

- **geradas pelo kernel** (via printk)
- **geradas pelo userspace** (geralmente o seu sistema init)

As mensagens do kernel estão sempre armazenadas no buffer **kmsg**, visível através do comando `dmesg`. Também são frequentemente copiadas para o seu **syslog**. Isto também se aplica a mensagens do userspace escritas em `/dev/kmsg`, mas essas são bastante raras.

Entretanto, quando o userspace escreve o seu elegante texto de estado de boot em `/dev/console` ou `/dev/tty1`, não é armazenado em lado nenhum. Vai apenas para o ecrã e é isso.

`dmesg` é usado para rever as mensagens de boot contidas no ring buffer do kernel. Um ring buffer é um buffer de tamanho fixo onde qualquer novo dado adicionado sobrescreve o dado mais antigo.

Mostra operações assim que o processo de boot é concluído, como opções de linha de comando passadas ao kernel; componentes de hardware detetados, eventos quando um novo dispositivo USB é adicionado, ou erros como falha da NIC (Network Interface Card) e os drivers reportam que não foi detetada atividade de ligação na rede e muito mais.

Se o registo do sistema for feito através do componente journal, deve usar `journalctl`. Este mostra mensagens que incluem mensagens do kernel e de boot; mensagens do syslog ou de vários serviços.

Problemas/erros de boot obrigam um administrador de sistemas a consultar certos ficheiros importantes em conjunto com comandos específicos (tratados de forma diferente por diferentes versões do Linux):

- `/var/log/boot.log` - log de boot do sistema, contém tudo o que aconteceu durante o boot do sistema
- `/var/log/messages` - armazena mensagens globais do sistema, incluindo as mensagens registadas durante o boot do sistema
- `/var/log/dmesg` - contém informação do ring buffer do kernel

Recursos úteis:

- [How to view all boot messages in Linux after booting? (original)](https://superuser.com/questions/1188407/how-to-view-all-boot-messages-in-linux-after-booting)
- [Differences in /var/log/{syslog,dmesg,messages} log files](https://superuser.com/questions/565927/differences-in-var-log-syslog-dmesg-messages-log-files)
- [How can the messages that scroll by when booting a Debian system be reviewed later?](https://serverfault.com/questions/516411/all-debian-boot-messages)

</details>

<details>
<summary><b>A utilização de swap está demasiado alta. Quais são as razões para isso e como resolver problemas de swapping?</b></summary><br>

O espaço **Swap** é uma quantidade restrita de memória física alocada para uso pelo sistema operativo quando a memória disponível está totalmente utilizada. É uma gestão de memória que envolve a troca de secções de memória de e para o armazenamento físico.

Se o sistema precisar de mais recursos de memória e a RAM estiver cheia, as páginas inativas na memória são movidas para o espaço de swap. Embora o espaço de swap possa ajudar máquinas com pouca RAM, não deve ser considerado um substituto para mais RAM. O espaço **Swap** está localizado em discos rígidos, que têm um tempo de acesso mais lento do que a memória física.

A carga de trabalho aumenta a sua procura por RAM. Está a executar uma carga de trabalho que requer mais memória. A utilização total do swap indica isso. Além disso, alterar `swappiness` para **1** pode não ser uma decisão sábia. Definir `swappiness` para **1** não indica que o swapping não será feito. Apenas indica quão agressivo o kernel será em relação ao swapping, não elimina o swapping. O swapping acontecerá se for necessário.

- **Aumentar o tamanho do espaço de swap** - primeiro, teria um aumento do uso do disco. Se os seus discos não forem suficientemente rápidos para acompanhar, o seu sistema pode acabar em thrashing, e experimentaria lentidões à medida que os dados são trocados de e para a memória. Isto resultaria num gargalo.

- **Adicionar mais RAM** - a verdadeira solução é adicionar mais memória. Não há substituto para a RAM, e se tiver memória suficiente, fará menos swapping.

Para monitorizar a utilização do espaço de swap:

- `cat /proc/swaps` - para ver o tamanho total e usado de swap
- `grep SwapTotal /proc/meminfo` - para mostrar o espaço total de swap
- `free` - para mostrar a quantidade de memória livre e usada do sistema (incluindo swap)
- `vmstat` - para verificar estatísticas de swapping
- `top`, `htop` - para verificar a utilização do espaço de swap
- `atop` - para mostrar se o seu sistema está a overcommitar memória
- ou use um comando shell one-liner para listar todas as aplicações com quanto espaço de swap estão a usar em kilobytes:```bash
for _fd in /proc/*/status ; do
  awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $_fd
done | sort -k 2 -n -r | less

**suid e bit executável do usuário ativado (s minúsculo)** - os bits `rwsr-x-r-x` estão definidos.```bash
chmod u+s b.pl
ls -lt b.pl
-rwsr-xr-x 1 root root 179 Jan  9 01:01 b.pl

**guid & bit executável do grupo ativado (s minúsculo)** - os bits `rwxr-sr-x` estão definidos.```bash
chmod g+s b.pl
ls -lt b.pl
-rwxr-sr-x 1 root root 179 Jan  9 01:01 b.pl

**3) Proprietário e grupo da aplicação**

Cada aplicação tem um **proprietário** designado (por exemplo, **u01-prod**, **u02-prod**) e um **grupo** (por exemplo, **g01-prod**, **g02-prod**) que são definidos como proprietário de todos os arquivos e diretórios no diretório do site:```bash
chown -R u01-prod:g01-prod /var/www/app01
chown -R u02-prod:g02-prod /var/www/app02

`df's` `-i` opção instrui-o a fornecer informações sobre inodes em cada sistema de arquivos em vez de sobre espaço disponível. Especificamente, diz ao df para retornar, para cada sistema de arquivos montado, o número total de inodes, o número de inodes livres, o número de inodes usados e a porcentagem de inodes usados. Esta opção pode ser usada em conjunto com a opção `-h` da seguinte forma para tornar a saída mais fácil de ler:```bash
df -hi

find . -inum 435304 -print
```
**Eliminando arquivos com nomes estranhos**

Às vezes, arquivos são criados com caracteres estranhos no nome. O sistema de arquivos Unix permite qualquer caractere como parte de um nome de arquivo, exceto um nulo (ASCII 000) ou uma "/". Todos os outros caracteres são permitidos.

Os usuários podem criar arquivos com caracteres que dificultam a visualização do diretório ou arquivo. Eles podem criar o diretório ".. " com um espaço no final, ou criar um arquivo que tenha um backspace no nome, usando:```bash
touch `printf "aa\bb"`
```
Agora o que acontece quando você usa o comando `ls`:````bash
ls
aa?b
ls | grep 'a'
ab
```
Note que quando o `ls` envia o resultado para um terminal, ele coloca um "**?**" no nome do arquivo para mostrar um caractere não imprimível.

Você pode se livrar desse arquivo usando `rm -i *` e ele irá solicitar confirmação antes de excluir cada arquivo. Mas você também pode usar o `find` para remover o arquivo, uma vez que você saiba o número do inode.```bash
ls -i
435304 aa?b
find . -inum 435304 -delete
```
Recursos úteis:

- [Entenda os conceitos básicos de inodes UNIX/Linux com exemplos](https://www.thegeekstuff.com/2012/01/linux-inodes/)
- [O que é um inode conforme definido pelo POSIX?](https://unix.stackexchange.com/questions/387087/what-is-an-inode-as-defined-by-posix/387093)

</details>

<details>
<summary><b><code>ls -l</code> mostra atributos de arquivo como pontos de interrogação. O que isso significa e que passos você tomará para remover arquivos "zumbis" não utilizados?</b></summary><br>

Este problema pode ser mais difícil de resolver porque várias etapas podem ser necessárias - às vezes você obtém `test/file: Permission denied`, `test/file: No such file or directory` ou `test/file: Input/output error`.

Isso acontece quando o usuário não pode executar um `stat()` nos arquivos (o que requer permissões de execução), mas pode ler as entradas do diretório (o que requer acesso de leitura no diretório). Então você obtém uma lista de arquivos no diretório, mas não consegue obter nenhuma informação sobre os arquivos porque eles não podem ser lidos. Se você tiver um diretório com permissão de leitura mas não de execução, verá isso.

Alguns processos como um `rsync` geram arquivos temporários que são criados e descartados rapidamente, o que causará erros se você tentar chamar outros comandos simples de gerenciamento de arquivos como `rm`, `mv` etc.

Exemplo de saída:```bash
?????????? ? ?        ?               ?            ? sess_kee6fu9ag7tiph2jae
```
1) alterar permissões: `chmod 0777 sess_kee6fu9ag7tiph2jae` e tentar remover
2) alterar proprietário: `chown root:root sess_kee6fu9ag7tiph2jae` e tentar remover
3) alterar permissões e proprietário do diretório: `chmod -R 0777 dir/ && chown -R root:root dir/` e tentar remover
4) recriar arquivo: `touch sess_kee6fu9ag7tiph2jae` e tentar remover
5) fique atento a outros processos em execução no servidor, por exemplo `rsync`, às vezes você pode ver isso como um erro transitório quando um servidor NFS está muito sobrecarregado
6) encontre o inode do arquivo: `ls -i`, e tente remover: `find . -inum <inode_num> -delete`
7) remonte (se possível) seu sistema de arquivos
8) inicialize o sistema em modo single-user e repare seu sistema de arquivos com `fsck`

Recursos úteis:

- [Interrogações aparecendo no ls do diretório. Erros de IO também.](https://serverfault.com/questions/65616/question-marks-showing-in-ls-of-directory-io-errors-too)

</details>

<details>
<summary><b>LVM ou não LVM. Quais benefícios ele oferece?</b></summary><br>

- O LVM torna muito fácil mover sistemas de arquivos
- você pode estender um grupo de volumes para um novo volume físico
- mover qualquer número de volumes lógicos de um volume físico antigo
- remover esse volume do grupo de volumes sem precisar desmontar nenhuma partição
- você também pode fazer snapshots de volumes lógicos para realizar backups
- o LVM tem suporte interno a espelhamento, então você pode ter um volume lógico espelhado em vários volumes físicos
- o LVM até suporta TRIM

Recursos úteis:

- [O que é LVM e para que serve?](https://askubuntu.com/questions/3596/what-is-lvm-and-what-is-it-used-for)

</details>

<details>
<summary><b>Como aumentar o tamanho de uma partição LVM?</b></summary><br>

Use o comando `lvextend` para redimensionar a partição LVM.

- estender o tamanho em 500MB:```bash
lvextend -L +500M /dev/vgroup/lvolume
```
- expandindo todo o espaço livre disponível:```bash
lvextend -l +100%FREE /dev/vgroup/lvolume
```
e `resize2fs` ou `xfs_growfs` para redimensionar o sistema de arquivos:

- para sistemas de arquivos ext:```bash
resize2fs /dev/vgroup/lvolume
```
- para o sistema de ficheiros xfs:```bash
xfs_growfs mountpoint_for_/dev/vgroup/lvolume
```
Recursos úteis:

- [Estendendo um volume lógico](https://www.tldp.org/HOWTO/LVM-HOWTO/extendlv.html)

</details>

<details>
<summary><b>O que é um processo zumbi/defunto?</b></summary><br>

É um processo que concluiu sua execução (através da chamada de sistema `exit`) mas ainda possui uma entrada na tabela de processos: é um processo no "**estado terminado**".

Processos marcados como **defuntos** são processos mortos (os chamados "zumbis") que permanecem porque seu pai não os destruiu corretamente. Esses processos serão destruídos pelo init se o processo pai for encerrado.

Recursos úteis:

- [O que é um processo <defunto> e por que ele não é morto?](https://askubuntu.com/questions/201303/what-is-a-defunct-process-and-why-doesnt-it-get-killed)

</details>

<details>
<summary><b>Qual é a maneira correta de atualizar/atualizar um sistema em produção? Você automatiza esses processos? Você define um tempo de inatividade para eles? Escreva recomendações. ***</b></summary><br>

A ser completado.

</details>

<details>
<summary><b>Seu amigo durante a configuração do servidor MySQL perguntou: <i>Devo executar <code>sudo mysql_secure_installation</code> após instalar o mysql?</i> O que você acha disso?</b></summary><br>

Seria melhor se você executar o comando, pois ele fornece muitas opções de segurança, como:

- Você pode definir uma senha para as contas root
- Você pode remover contas root que são acessíveis fora do host local
- Você pode remover contas de usuários anônimos
- Você pode remover o banco de dados de teste, que por padrão pode ser acessado por usuários anônimos

Recursos úteis:

- [Qual é o propósito de usar mysql_secure_installation?](https://stackoverflow.com/questions/20760908/what-is-purpose-of-using-mysql-secure-installation)

</details>

<details>
<summary><b>Apresente e explique as boas maneiras de usar o comando <code>kill</code>.</b></summary><br>

Falando sobre matar processos, nunca use `kill -9/SIGKILL` a menos que seja absolutamente necessário. Esse kill pode causar problemas devido à sua força bruta.

Sempre tente usar o seguinte procedimento simples:

- primeiro, envie o sinal **SIGTERM** (`kill -15`) primeiro, que diz ao processo para desligar e geralmente é aceito como o sinal a ser usado ao desligar de forma limpa (mas lembre-se de que esse sinal pode ser ignorado).
- em seguida, tente enviar o sinal **SIGHUP** (`kill -1`), que é comumente usado para dizer a um processo para desligar e reiniciar; este sinal também pode ser capturado e ignorado por um processo.

A grande maioria das vezes, isso é tudo o que você precisa – e é muito mais limpo.

Recursos úteis:

- [Quando não devo usar kill -9 em um processo?](https://unix.stackexchange.com/questions/8916/when-should-i-not-kill-9-a-process)
- [SIGTERM vs. SIGKILL](https://major.io/2010/03/18/sigterm-vs-sigkill/)

</details>

<details>
<summary><b>O que é o comando <code>strace</code> e como deve ser usado? Explique um exemplo de conexão a um processo já em execução.</b></summary><br>

`strace` é uma poderosa ferramenta de linha de comando para depuração e solução de problemas de programas em sistemas operacionais do tipo Unix, como Linux. Ele captura e registra todas as chamadas de sistema feitas por um processo e os sinais recebidos pelo processo.

**Visão geral do Strace**

`strace` pode ser visto como um depurador leve. Ele permite que um programador/usuário descubra rapidamente como um programa está interagindo com o SO. Ele faz isso monitorando chamadas de sistema e sinais.

**Usos**

Bom para quando você não tem o código fonte ou não quer se preocupar em realmente analisá-lo. Também é útil para seu próprio código se você não quiser abrir o **GDB**, mas estiver apenas interessado em entender a interação externa.

**Exemplo de anexação ao processo**

`strace -p <PID>` - para anexar um processo ao strace.

`strace -e trace=read,write -p <PID>` - com isso você também pode rastrear um processo/programa para um evento, como read e write (neste exemplo). Assim, aqui ele imprimirá todos esses eventos que incluem chamadas de sistema read e write pelo processo.

Outros exemplos

- `-e trace=network` - rastreia todas as chamadas de sistema relacionadas à rede.
- `-e trace=signal` - rastreia todas as chamadas de sistema relacionadas a sinais.
- `-e trace=ipc` - rastreia todas as chamadas de sistema relacionadas a IPC.
- `-e trace=desc` - rastreia todas as chamadas de sistema relacionadas a descritores de arquivo.
- `-e trace=memory` - rastreia todas as chamadas de sistema relacionadas a mapeamento de memória.

Recursos úteis:

- [Como o strace deve ser usado? (original)](https://stackoverflow.com/questions/174942/how-should-strace-be-used)
- [Como o strace se conecta a um processo já em execução? (original)](https://stackoverflow.com/questions/7482076/how-does-strace-connect-to-an-already-running-process)
- [strace: por diversão, lucro e depuração](http://timetobleed.com/hello-world/)

</details>

<details>
<summary><b>Quando você usaria listas de controle de acesso em vez de ou em conjunto com o comando <code>chmod</code>? ***</b></summary><br>

A ser completado.

</details>

<details>
<summary><b>Quais algoritmos são suportados no arquivo <code>/etc/shadow</code>?</b></summary><br>

Os algoritmos típicos atuais são:

- MD5
- SHA-1 (também chamado de SHA)

ambos não devem mais ser usados para fins criptográficos/de segurança!!

- SHA-256
- SHA-512
- SHA-3 (KECCAK foi anunciado como vencedor da competição por um novo algoritmo hash aprovado federalmente em outubro de 2012)

Recursos úteis:

- [Qual é o algoritmo usado para criptografar senhas do Linux?](https://crypto.stackexchange.com/questions/40841/what-is-the-algorithm-used-to-encrypt-linux-passwords)
- [Como encontrar o algoritmo de hash usado para ofuscar senhas?](https://unix.stackexchange.com/questions/430141/how-to-find-the-hashing-algorithm-used-to-obfuscate-passwords)

</details>

<details>
<summary><b>Qual é o uso do ulimit em sistemas do tipo Unix?</b></summary><br>

A maioria dos sistemas operacionais do tipo Unix, incluindo Linux e BSD, fornece maneiras de limitar e controlar o uso de recursos do sistema, como threads, arquivos e conexões de rede, por processo e por usuário. Esses "**ulimits**" impedem que usuários individuais usem muitos recursos do sistema.

</details>

<details>
<summary><b>O que são limites flexíveis e limites rígidos?</b></summary><br>

**Limite rígido** é o máximo permitido para um usuário, definido pelo superusuário ou root. Este valor é definido no arquivo `/etc/security/limits.conf`. O usuário pode aumentar o **limite flexível** por conta própria quando precisar de mais recursos, mas não pode definir o **limite flexível** acima do **limite rígido**.

</details>

<details>
<summary><b>Durante a configuração do HAProxy para funcionar com Redis, você obtém <code>General socket error (Permission denied)</code> no log. O SELinux está ativado. Explique a solução básica de problemas do SELinux na CLI. ***</b></summary><br>

Recursos úteis:

- [Solução básica de problemas do SELinux na CLI](https://access.redhat.com/articles/2191331)

</details>

<details>
<summary><b>Você configurou um login de chave RSA, mas seu servidor mostra <code>Server refused our key</code> conforme esperado. Onde você procurará a causa do problema?</b></summary><br>

**Lado do servidor**

Definir `LogLevel VERBOSE` no arquivo `/etc/ssh/sshd_config` é provavelmente o que você precisa, embora existam níveis mais altos:

As falhas de autenticação SSH são registradas em `/var/log/auth.log`, `/var/log/secure` ou `/var/log/audit/audit.log`.

O seguinte deve fornecer apenas linhas de log relacionadas ao SSH (por exemplo):```bash
grep 'sshd' /var/log/auth.log
```
Em seguida, o comando mais simples para listar todas as tentativas de login SSH falhadas é o mostrado abaixo:```bash
grep "Failed password" /var/log/auth.log
```
também é útil:```bash
grep "Failed\|Failure" /var/log/auth.log
```
Em distribuições Linux mais recentes, você pode consultar o arquivo de log de tempo de execução mantido pelo daemon Systemd através do comando `journalctl` (`ssh.service` ou `sshd.service`). Por exemplo:

```bash```bash
journalctl _SYSTEMD_UNIT=ssh.service | egrep "Failed|Failure"
```
**Lado do cliente**

Lembre-se também de executar o cliente SSH com `-v|--verbose` - está no primeiro nível de verbosidade. Em seguida, você pode ativar verbosidade adicional (nível 2 e 3) para ainda mais mensagens de depuração, conforme mostrado com, por exemplo, `-vv`.

Recursos úteis:

- [Ativar Modo de Depuração no SSH para Solucionar Problemas de Conectividade](https://www.tecmint.com/enable-debugging-mode-in-ssh/)

</details>

<details>
<summary><b>Por que a maioria das distribuições usa ext4, em vez de XFS ou outros sistemas de arquivos? Por que existem tantos deles? ***</b></summary><br>

A ser concluído.

</details>

<details>
<summary><b>Um gerente de projeto precisa de um novo SQL Server. O que você pergunta a ele/ela? ***</b></summary><br>

Quero que o DBA faça perguntas como:

- Qual será o tamanho do banco de dados? (se podemos adicionar o banco de dados a um servidor existente)
- Quão crítico é o banco de dados? (sobre clustering, recuperação de desastres, alta disponibilidade)

</details>

<details>
<summary><b>Criar um arquivo com 100 linhas com valores aleatórios.</b></summary><br>

Por exemplo:

```bash```bash
cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 100 > /path/to/file
```
</details>

<details>
<summary><b>Como executar script como outro usuário sem senha?</b></summary><br>

Por exemplo (com o comando `visudo`):```bash
user1 ALL=(user2) NOPASSWD: /opt/scripts/bin/generate.sh
```
Os caminhos dos comandos devem ser absolutos! Em seguida, chame `sudo -u user2 /opt/scripts/bin/generate.sh` a partir de um shell user1.

</details>

<details>
<summary><b>Como verificar se está executando como root em um script bash? O que você deve observar?</b></summary><br>

Em um script bash, você tem várias maneiras de verificar se o usuário em execução é root.

Como aviso, não verifique se um usuário é root usando o nome de usuário root. Nada garante que o usuário com ID 0 seja chamado root. É uma convenção muito forte que é amplamente seguida, mas qualquer pessoa poderia renomear o superusuário para outro nome.

Acho que a melhor maneira ao usar bash é usar `$EUID` porque `$UID` pode ser alterado e não refletir o usuário real executando o script.```bash
if (( $EUID != 0 )); then
  echo "Please run as root"
  exit
fi
```
</details>

<details>
<summary><b>Podes dar um exemplo específico de quando é indicado usar a conta <code>nobody</code>? Fala-me das diferenças em executar o serviço httpd como uma conta <code>nobody</code> e <code>www-data</code>.</b></summary><br>

Em muitas variantes Unix, `nobody` é o nome convencional de uma conta de utilizador que não possui ficheiros, não está em grupos privilegiados e não tem capacidades além daquelas que qualquer outro utilizador tem.

É comum executar daemons como `nobody`, especialmente servidores, de forma a limitar os danos que um utilizador malicioso poderia causar ao obter controlo sobre eles.

No entanto, a utilidade desta técnica é reduzida se mais do que um daemon for executado desta forma, porque obter controlo de um daemon daria controlo sobre todos eles. A razão é que os processos pertencentes a `nobody` têm a capacidade de enviar sinais uns aos outros e até depurar uns aos outros, permitindo-lhes ler ou até modificar a memória uns dos outros.

**Quando devo usar a conta `nobody`?**

Quando não são necessárias permissões para as operações de um programa. Isto é mais notável quando não vai haver qualquer atividade de disco.

Um exemplo real disto é o **memcached** (uma cache/base de dados/coisa em memória chave-valor), a correr no meu computador e no meu servidor sob a conta `nobody`. Porquê? Porque simplesmente não precisa de nenhuma permissão e dar-lhe uma conta que tivesse acesso de escrita a ficheiros seria apenas um risco desnecessário.

Um bom exemplo são também os servidores web. Imagina se o Apache corresse como root e alguém encontrasse uma forma de enviar comandos personalizados para a consola através do Apache, teria acesso a todo o teu sistema.

A conta `nobody` também é usada como uma shell restrita para dar acesso ao sistema de ficheiros aos utilizadores sem uma shell real como o bash. Isto deve impedi-los de conseguir executar coisas.

**`nobody` ou `www-data` para httpd (Apache)**

Ao iniciar, o Apache precisa de acesso root, mas rapidamente abandona esse acesso e assume a identidade de um utilizador não privilegiado. Este utilizador pode ser `nobody` ou `apache`, ou `www-data`.

Várias aplicações usam o utilizador `nobody` como padrão. Por exemplo, provavelmente nunca queres que o serviço Apache sobrescreva ficheiros que pertencem ao bind. Ter uma conta por serviço tende a ser uma ideia muito boa.

Fazer o Apache correr como `nobody:nobody` é bastante fácil, basta atualizar as definições de utilizador e grupo. Mas como mencionei acima, não recomendo esse utilizador/grupo em particular. É perfeitamente possível que sejas tentado a adicionar um serviço ao sistema no futuro que também corra como `nobody`, e esquecer-te-ás que deste acesso de escrita no sistema de ficheiros ao utilizador `nobody`.

Se, de alguma forma, `nobody` fosse comprometido, poderia ter mais impacto do que se fosse um utilizador isolado para a aplicação, como `www-data`. Claro que muito disto dependerá das permissões de ficheiro e grupo. `nobody` usa as permissões de outros, enquanto um utilizador específico da aplicação poderia ser configurado para permitir acesso de leitura a ficheiros, mas outros ainda poderiam ser negados.

Recursos úteis:

- [What is nobody user and group?](https://unix.stackexchange.com/questions/186568/what-is-nobody-user-and-group)
- [The Linux and Unix Nobody User](http://linuxg.net/the-linux-and-unix-nobody-user/)
- [What is the purpose of the 'nobody' user?](https://askubuntu.com/questions/329714/what-is-the-purpose-of-the-nobody-user)

</details>

<details>
<summary><b>Existe alguma forma de redirecionar a saída para um ficheiro e também exibi-la no stdout?</b></summary><br>

O comando que procuras chama-se tee:

`foo | tee output.file`

Por exemplo, se só te importas com o stdout:

`ls -a | tee output.file`

Se quiseres incluir o stderr, faz:

`program [arguments...] 2>&1 | tee outfile`

`2>&1` redireciona o canal 2 (stderr/erro padrão) para o canal 1 (stdout/saída padrão), de modo que ambos são escritos como stdout. Também é direcionado para o ficheiro de saída indicado graças ao comando tee.

Além disso, se quiseres adicionar ao ficheiro de log, usa `tee -a`:

`program [arguments...] 2>&1 | tee -a outfile`

</details>

<details>
<summary><b>Qual é o shebang bash preferido e porquê? Qual é a diferença entre executar um ficheiro usando <code>./script</code> ou <code>bash script</code>?</b></summary><br>

Deves usar `#!/usr/bin/env bash` por portabilidade: diferentes \*nixes colocam o bash em locais diferentes, e usar `/usr/bin/env` é uma forma de contornar isso para executar o primeiro bash encontrado no `PATH`.

Executar `./script` faz exatamente isso, e requer permissão de execução no ficheiro, mas é agnóstico quanto ao tipo de programa. Pode ser um **script bash**, um **script sh**, ou um **script Perl**, **Python**, **awk**, ou **expect**, ou um **binário executável** real. Executar `bash script` forçaria a sua execução sob `sh`, em vez de qualquer outra coisa.

Recursos úteis:

- [What is the preferred Bash shebang? (original)](https://stackoverflow.com/questions/10376206/what-is-the-preferred-bash-shebang)

</details>

<details>
<summary><b>Tens de executar um comando que vai demorar muito tempo. Como evitar que este processo seja interrompido após a sessão ssh ser perdida?</b></summary><br>

Usa `nohup` para fazer o teu processo ignorar o sinal de hangup:```bash
nohup long-running-process &
exit
```
ou se você quiser usar **GNU Screen**:```bash
screen -d -m long-running-process
exit
```
Recursos úteis:

- [5 Maneiras de Manter Sessões SSH Remotas e Processos em Execução Após a Desconexão](https://www.tecmint.com/keep-remote-ssh-sessions-running-after-disconnection/)

</details>

<details>
<summary><b>Qual é o principal propósito das autoridades de certificação intermediárias?</b></summary><br>

Para descobrir o principal propósito de uma CA intermediária, você deve primeiro aprender sobre **CAs Raiz**, **CAs Intermediárias** e a **Cadeia de Confiança do Certificado SSL**.

**CAs Raiz** são CAs primárias que normalmente não assinam diretamente certificados de entidade final/servidor. Elas emitem certificados raiz que geralmente são pré-instalados em todos os navegadores, dispositivos móveis e aplicativos. A chave privada desses certificados é usada para assinar outros certificados subsequentes chamados certificados intermediários. As CAs Raiz geralmente são mantidas “offline” e em um ambiente altamente seguro com acesso rigorosamente limitado.

**CAs Intermediárias** são CAs que se subordinam à CA Raiz por um ou mais níveis, sendo confiadas por estas para assinar certificados em seu nome. O propósito de criar e usar CAs Intermediárias é principalmente por segurança, pois se a chave privada intermediária for comprometida, a CA Raiz pode revogar o certificado intermediário e criar um novo com um novo par de chaves criptográficas.