Sistemas Operacionais (Windows e Linux) para o Agente de Tecnologia do Banco do Brasil

Processos e threads: como o sistema executa programas

Conceito

Processo é uma instância de um programa em execução, com espaço de memória próprio, identificador (PID) e recursos associados (arquivos abertos, sockets, variáveis de ambiente). Thread é uma linha de execução dentro de um processo; threads compartilham a mesma memória do processo, mas têm pilha e registradores próprios. Em geral, processos isolam melhor falhas; threads facilitam paralelismo dentro do mesmo aplicativo.

Estados comuns: pronto (ready), executando (running), bloqueado/esperando (waiting), finalizado (terminated). O sistema operacional alterna a CPU entre processos/threads usando escalonamento.

Escalonamento (noções cobradas em prova)

• Preemptivo: o SO pode interromper uma tarefa para dar CPU a outra (comum em Windows e Linux).
• Quantum: fatia de tempo de CPU para cada tarefa.
• Prioridade: tarefas com maior prioridade tendem a receber CPU antes.
• Context switch: troca de execução entre tarefas; tem custo (tempo) e pode impactar desempenho quando há muitas threads.

Passo a passo prático (Linux): listar e inspecionar processos

1) Ver processos em tempo real:

top

2) Alternativa mais amigável (se disponível):

htop

3) Listar processos e filtrar por nome:

Continue em nosso aplicativo

Você poderá ouvir o audiobook com a tela desligada, ganhar gratuitamente o certificado deste curso e ainda ter acesso a outros 5.000 cursos online gratuitos.

ou continue lendo abaixo...

Baixar o aplicativo

ps aux | grep nginx

4) Ver árvore de processos (pai/filho):

pstree -p

5) Ajustar prioridade (nice/renice):

nice -n 10 comando_pesado

renice -n 5 -p 1234

Interpretação: valores de nice maiores tendem a reduzir prioridade (mais “gentil” com o sistema). Em troubleshooting, isso ajuda a conter impacto de rotinas pesadas.

Passo a passo prático (Windows): processos e serviços

1) Ver processos e consumo: abra o Gerenciador de Tarefas (Ctrl+Shift+Esc) > aba Processos e ordene por CPU/Memória.

2) Detalhar PID e afinidade/prioridade: aba Detalhes > clique direito no processo.

3) Via PowerShell (listar processos):

Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

4) Identificar serviço associado (quando aplicável):

Get-Service | Where-Object {$_.Status -eq 'Running'}

Gerenciamento de memória: RAM, paginação e sintomas

Conceito

O SO gerencia memória para isolar processos e maximizar uso da RAM. Quando a RAM fica insuficiente, ocorre paginação (swap/pagefile): parte da memória é movida para disco. Isso reduz desempenho e pode causar lentidão generalizada.

• Memória virtual: abstração que permite a cada processo “enxergar” um espaço contínuo.
• Page cache/buffer cache (Linux): o sistema usa RAM para cache de arquivos, acelerando I/O; não é necessariamente “memória perdida”.
• OOM (Out Of Memory): no Linux, o kernel pode encerrar processos quando falta memória (OOM killer).

Passo a passo prático (Linux): verificar RAM e swap

1) Visão geral:

free -h

2) Detalhar uso por processo (ordem por memória):

ps aux --sort=-%mem | head

3) Ver swap:

swapon --show

4) Ver pressão de memória e swap em tempo real:

vmstat 1

Leitura rápida: se o sistema está usando swap intensamente e o disco fica ocupado, é um indício de falta de RAM ou vazamento de memória em algum serviço.

Passo a passo prático (Windows): identificar pressão de memória

1) Gerenciador de Tarefas > aba Desempenho > Memória: observe “Em uso”, “Disponível” e “Comprometida”.

2) PowerShell (top por Working Set):

Get-Process | Sort-Object WorkingSet64 -Descending | Select-Object -First 10 Name,Id,@{n='WS(MB)';e={[math]::Round($_.WorkingSet64/1MB,1)}}

Interpretação: “Comprometida” alta e paginação frequente sugerem pressão de memória. Em servidores, isso costuma aparecer como lentidão e timeouts.

Sistemas de arquivos: estrutura, caminhos e operações

Conceito

Sistema de arquivos define como dados são organizados em disco: diretórios, arquivos, metadados (tamanho, datas, permissões). Em Linux, o caminho é baseado em “/” e tudo se encaixa em uma única árvore. Em Windows, há letras de unidade (C:, D:) e caminhos com “\”.

• Linux: diretórios importantes incluem /etc (configurações), /var/log (logs), /home (usuários), /tmp (temporários).
• Windows: pastas comuns incluem C:\Windows, C:\Program Files, C:\Users, e logs via Visualizador de Eventos.

Passo a passo prático (Linux): navegação e manipulação de arquivos

1) Onde estou e o que há aqui:

pwd

ls -lah

2) Entrar em diretório:

cd /var/log

3) Criar, copiar, mover e remover:

mkdir testes

cp arquivo.txt testes/

mv testes/arquivo.txt testes/arquivo-renomeado.txt

rm testes/arquivo-renomeado.txt

rmdir testes

4) Buscar texto em arquivos (útil para logs):

grep -R "ERROR" /var/log

5) Localizar arquivos:

find /etc -name "*.conf"

Passo a passo prático (Windows): operações equivalentes

1) Listar arquivos (PowerShell):

Get-ChildItem -Force

2) Criar pasta e arquivo:

New-Item -ItemType Directory -Name testes

New-Item -ItemType File -Path .\testes\arquivo.txt

3) Copiar e mover:

Copy-Item .\testes\arquivo.txt .\testes\arquivo-copia.txt

Move-Item .\testes\arquivo-copia.txt .\testes\arquivo-renomeado.txt

4) Remover:

Remove-Item .\testes\arquivo-renomeado.txt

Permissões, usuários e grupos: controle de acesso

Conceito (Linux)

No Linux, permissões clássicas são r (read), w (write), x (execute) para três classes: dono (user), grupo (group) e outros (others). O comando ls -l mostra algo como -rwxr-x---.

• chmod: altera permissões.
• chown: altera dono.
• chgrp: altera grupo.
• sudo: elevação de privilégio para executar tarefas administrativas.

Passo a passo prático (Linux): ajustar permissões e propriedade

1) Ver permissões:

ls -l arquivo.sh

2) Tornar executável para o dono:

chmod u+x arquivo.sh

3) Definir permissões numéricas (ex.: 640 = rw- r-- ---):

chmod 640 arquivo.conf

4) Trocar dono e grupo:

sudo chown appuser:appgroup arquivo.conf

5) Entender o “porquê” de um acesso negado: confirme usuário/grupo e permissões do diretório pai (sem x no diretório, não há travessia).

Conceito (Windows)

No Windows, permissões são baseadas em ACL (listas de controle de acesso) com entradas por usuário/grupo (ex.: Ler, Modificar, Controle total). Há herança de permissões por pastas. A elevação ocorre via UAC e grupos administrativos.

Passo a passo prático (Windows): inspecionar e ajustar permissões

1) Interface: clique direito na pasta > Propriedades > Segurança para ver grupos/usuários e permissões.

2) PowerShell (ver ACL):

Get-Acl C:\caminho\pasta | Format-List

3) Diagnóstico rápido: se um serviço não acessa um arquivo, verifique a conta do serviço e se ela tem permissão na pasta e no arquivo.

Serviços e rotinas administrativas

Linux: systemd (serviços)

Em muitas distribuições, serviços são gerenciados pelo systemd. Um serviço pode estar ativo, inativo, falhando, ou reiniciando.

Passo a passo prático (Linux): verificar e corrigir falha de serviço

1) Ver status do serviço:

systemctl status nginx

2) Iniciar/parar/reiniciar:

sudo systemctl start nginx

sudo systemctl stop nginx

sudo systemctl restart nginx

3) Habilitar no boot:

sudo systemctl enable nginx

4) Ver logs do serviço (journal):

journalctl -u nginx --since "1 hour ago"

5) Se falhar ao subir: procure mensagens como “permission denied”, “address already in use”, “config test failed”. Em seguida, valide configuração (quando existir comando de teste) e portas em uso.

Windows: serviços

Serviços são processos gerenciados pelo Service Control Manager. Podem rodar como LocalSystem, NetworkService, LocalService ou uma conta específica. Falhas podem ser vistas no Visualizador de Eventos e nas propriedades do serviço (recuperação).

Passo a passo prático (Windows): verificar serviço e eventos

1) Abrir Serviços: execute services.msc e localize o serviço.

2) Ver estado e reiniciar: clique direito > Iniciar/Parar/Reiniciar.

3) PowerShell (status):

Get-Service | Where-Object {$_.Name -like '*sql*'} | Format-Table Name,Status,StartType

4) Ver eventos relacionados (PowerShell):

Get-WinEvent -LogName System -MaxEvents 50 | Select-Object TimeCreated,Id,LevelDisplayName,Message

5) No Visualizador de Eventos: Logs do Windows > Sistema e Aplicativo. Filtre por nível (Erro/Crítico) e por origem do serviço.

Logs e troubleshooting: método prático

Roteiro de diagnóstico (aplicável a Linux e Windows)

• 1) Sintoma: o que falha? (lentidão, indisponibilidade, erro de permissão, timeout)
• 2) Recurso: CPU, memória, disco, rede, limite de arquivos/handles
• 3) Serviço: está rodando? reinicia sozinho? há dependências?
• 4) Logs: erro exato, horário, recorrência
• 5) Mudanças recentes: deploy, configuração, patch, certificado, permissão

Exemplo prático 1: CPU alta no Linux

Cenário: servidor lento e CPU em 100%.

1) Identificar processo consumidor:

top

2) Confirmar com ordenação por CPU:

ps aux --sort=-%cpu | head

3) Ver threads (quando necessário):

top -H -p 1234

4) Ação típica: reduzir prioridade (mitigação) e investigar causa (loop, carga, fila). Mitigação:

sudo renice -n 10 -p 1234

Exemplo prático 2: serviço não inicia no Linux

Cenário: systemctl status mostra “failed”.

1) Ver status e última falha:

systemctl status minhaapp

2) Ver logs detalhados:

journalctl -u minhaapp -n 200

3) Erro comum: permissão em arquivo de configuração. Verificar dono/permissões:

ls -l /etc/minhaapp/config.yml

4) Corrigir propriedade/permissão (exemplo):

sudo chown minhaapp:minhaapp /etc/minhaapp/config.yml

sudo chmod 640 /etc/minhaapp/config.yml

Exemplo prático 3: falha de serviço no Windows com evento

Cenário: serviço para sozinho.

1) Verificar serviço e conta:

Get-Service NomeDoServico

2) Consultar eventos recentes do Sistema:

Get-WinEvent -LogName System -MaxEvents 200 | Where-Object {$_.LevelDisplayName -in 'Error','Critical'} | Select-Object -First 20 TimeCreated,Id,Message

3) Se o erro indicar “Access is denied”: validar ACL da pasta usada pelo serviço e se a conta do serviço tem permissão de leitura/escrita.

Monitoramento essencial: o que observar

Linux

• CPU: top, uptime (load average), ps
• Memória: free -h, vmstat
• Disco: df -h (espaço), du -sh * (uso por pasta)
• Logs: journalctl, arquivos em /var/log

Windows

• CPU/Memória: Gerenciador de Tarefas, Monitor de Recursos
• Disco: Gerenciador de Tarefas > Desempenho; Monitor de Recursos
• Logs: Visualizador de Eventos (Sistema/Aplicativo), Get-WinEvent
• Serviços: services.msc, Get-Service

Exercícios (correspondência): comando → resultado esperado

Parte A: Linux

Instrução: associe cada comando ao resultado mais provável.

• 1) pwd
• 2) ls -lah
• 3) chmod 640 arquivo.conf
• 4) chown app:app arquivo.conf
• 5) systemctl status nginx
• 6) journalctl -u nginx --since "1 hour ago"
• 7) ps aux --sort=-%cpu | head
• 8) df -h

Resultados:

• A) Mostra o diretório atual.
• B) Lista arquivos com detalhes, incluindo ocultos, tamanhos legíveis e permissões.
• C) Define permissões para dono ler/escrever, grupo ler, outros sem acesso.
• D) Altera dono e grupo do arquivo para “app”.
• E) Exibe estado do serviço, PID, últimas mensagens e se está “active/failed”.
• F) Exibe logs do serviço no período indicado.
• G) Lista os processos que mais consomem CPU.
• H) Mostra uso de espaço em disco por partição/montagem.

Parte B: Windows

Instrução: associe cada comando/ação ao resultado esperado.

• 1) Abrir services.msc
• 2) Get-Process | Sort-Object CPU -Descending | Select-Object -First 10
• 3) Get-WinEvent -LogName System -MaxEvents 50
• 4) Propriedades da pasta > guia Segurança
• 5) Get-Acl C:\dados\app

Resultados:

• A) Gerenciar serviços (iniciar/parar/reiniciar, tipo de inicialização).
• B) Listar os 10 processos com maior tempo de CPU acumulado (ordem decrescente).
• C) Ler eventos recentes do log de Sistema (inclui falhas de serviço/driver).
• D) Visualizar/editar permissões (ACL) via interface gráfica.
• E) Exibir a ACL do caminho informado via PowerShell.