Sistemas Operacionais

Fundamentos de Sistemas Operacionais

O que é um sistema operacional?

Os sistemas operacionais realizam duas funções essencialmente não relacionadas: (1) fornecer a programadores de aplicativos (e programas aplicativos, claro) um conjunto de recursos abstratos limpo em vez de recursos confusos de hardware, e (2) gerenciar esses recursos de hardware

O que é um sistema operacional?

Usando essa abstração, os programas podem criar, escrever, ler arquivos, sem ter que lidar com detalhes complexos de como o hardware funciona

O que é um sistema operacional?

O conceito de um sistema operacional como fundamentalmente fornecendo abstrações para programas aplicativos é uma visão top-down (abstração de cima para baixo). Uma visão alternativa, bottom-up (abstração de baixo para cima), sustenta que o sistema operacional está ali para gerenciar todas as partes de um sistema complexo.

O que é um sistema operacional?

O que é um sistema operacional?

1. Quando múltiplas saídas de impressão estão na fila para serem impressas em uma única impressora, uma decisão tem de ser tomada sobre qual deve ser impressa em seguida.

2. Em vez de os clientes se revezarem, cada um tem direito a uma parte do recurso. Por exemplo, a memória principal é normalmente dividida entre vários programas sendo executados, de modo que cada um pode ser residente ao mesmo tempo (por exemplo, a fim de se revezar usando a CPU).

Revisão sobre hardware de computadores

A CPU, memória e dispositivos de E/S estão todos conectados por um sistema de barramento (bus) e comunicam-se uns com os outros sobre ele.

Revisão sobre hardware de computadores

Processadores

O “cérebro” do computador é a CPU. O ciclo básico de toda CPU é buscar a primeira instrução da memória, decodificá-la para determinar o seu tipo e operandos, executá-la.

Revisão sobre hardware de computadores

Memória

Exemplo de utilização de cache

O zoológico dos sistemas operacionais

• Sistemas operacionais de computadores de grande porte, de alto desempenho e alta disponibilidade (mainframes)
• Sistemas operacionais de servidores
• Sistemas operacionais de computadores pessoais
• Sistemas operacionais de computadores portáteis
• Sistemas operacionais embarcados
• Sistemas operacionais de tempo real

Conceitos de sistemas operacionais

• Processos: um processo é basicamente um programa em execução e associado a cada processo está um espaço de endereçamento, uma lista de posições de mémoria que vai de 0 a algum máximo, onde o processo pode ler e escrever.
• Espaços de endereçamento: diz respeito ao gerenciamento e à proteção da memória principal do computador, quando se tem multiplos processos sendo executados.
• Arquivos: um sistema de arquivos é uma estrutura usada por um sistema operacional para organizar e gerenciar arquivos em um dispositivo de armazenamento. Chamadas do sistemas são necessárias para criar, remover, ler escrever arquivos. Existe o conceito de diretório como uma maneira de agrupar os arquivos

Conceitos de sistemas operacionais

• Entrada/Saída: o sistema operacional tem um subsistema de E/S para gerenciamento dos dispositivos.
• Proteção: o sistema operacional gerencia a segurança do sistema de maneira que os arquivos, por exemplo, sejam acessíveis somente por usuários autorizados.
• Interpretador de comandos (shell): é a principal interface entre um usuário e o sistema operacional.

Conceitos de sistemas operacionais

Memória virtual: A memória virtual proporciona a capacidade de executar programas maiores do que a memória física da máquina, rapidamente movendo pedaços entre a memória RAM e o disco.

Quando se instala o linux é possível definir o tamanho da partição do disco que será utilizado pela memória virtual (swap).

free

              total        used        free      shared  buff/cache   available
Mem:        13290480      480388    10480984        1252     2329108    12527384
Swap:              0           0           0

Chamadas de sistema

Já vimos que os sistemas operacionais apresentam duas funções: abstrações para os usuários e gerenciamento de recursos.

Chamadas de sistema

Chamadas de sistema

API: elemento que proporciona uma ligação física ou lógica entre dois sistemas ou partes de um sistema que não poderiam ser conectados diretamente.

• API define um conjunto de normas que possibilita a comunicação entre plataformas por meio de uma série de padrões e protocolos.
• Por meio de APIs, desenvolvedores podem criar novos softwares e aplicativos capazes de se comunicar com outras plataformas. Por exemplo: caso um desenvolvedor queira criar um aplicativo de fotos para Android, ele poderá ter acesso à câmera do celular através da API do sistema operacional, sem ter a necessidade de criar uma nova interface de câmera do zero..

Aqui uma abstração da complexidade!

Chamadas de sistema

As chamadas de sistema sempre foram o meio pelo qual os programas de espaço do usuário podem acessar os serviços do kernel

mkdir mynewdir

cat /usr/include/asm*/unistd.h | grep -B 1 sys_mkdir

#define __NR_mkdirat 34
__SYSCALL(__NR_mkdirat, sys_mkdirat)

cpuid -1 -r | head -3

CPU:
   0x00000000 0x00: eax=0x0000000d ebx=0x756e6547 ecx=0x6c65746e edx=0x49656e69
   0x00000001 0x00: eax=0x000406f0 ebx=0x01020800 ecx=0xfefa3203 edx=0x1f8bfbff

Chamadas de sistema

Uma chamada de sistem pode necessitar de outras chamadas serem realizadas

strace -c mkdir mynewdir

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  0.00    0.000000           0         5           read
  0.00    0.000000           0         8           close
  0.00    0.000000           0        18           mmap
  0.00    0.000000           0         7           mprotect
  0.00    0.000000           0         1           munmap
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         4           pread64
  0.00    0.000000           0         2         2 access
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         1           mkdir
  0.00    0.000000           0         2         2 statfs
  0.00    0.000000           0         2         1 arch_prctl
  0.00    0.000000           0         1           set_tid_address
  0.00    0.000000           0        26        20 openat
  0.00    0.000000           0        26        20 newfstatat
  0.00    0.000000           0         1           set_robust_list
  0.00    0.000000           0         1           prlimit64
  0.00    0.000000           0         1           getrandom
  0.00    0.000000           0         1           rseq
------ ----------- ----------- --------- --------- ----------------
100.00    0.000000           0       111        45 total

• A lista de chamadas existentes aqui
• Para consultar no sistema operacional a página da mensagem man 2 mkdir

Chamadas de sistema

Chamadas de sistema

write.cpp

#include<unistd.h>

int main() 
{
    write(1, "Ola Mundo!", 10);
}

Chamada de sistema

Abaixo a chamada de sistema write sendo utilizada

strace -o trace.txt ./a.out

cat trace.txt | grep -A 5 write

write(1, "Ola Mundo!", 10)              = 10
exit_group(0)                           = ?
+++ exited with 0 +++

Chamada de sistema

No fim das contas um printf realiza a mesma chamada de sistema write

write.cpp

#include<stdio.h>

int main() 
{
    printf("Ola Mundo!");
}

strace -o trace.txt ./a.out

cat trace.txt | grep -A 5 write

write(1, "Ola Mundo!", 10)              = 10
exit_group(0)                           = ?
+++ exited with 0 +++

Chamada de sistema

strace -o trace.txt python -c 'print("Ola Mundo!")'

cat trace.txt | grep -A 5 write 

• Será realizada a chamada de sistema write?
• Comparar com as chamadas de sistema feitas com C++

Chamadas de sistema

• Chamadas de sistema para gerenciamento de processos
• Chamadas de sistema para gerenciamento de arquivos
• Chamadas de sistema para gerenciamento de diretórios
• Chamadas de sistema diversas

Chamadas de sistema para gerenciamento de processos

Chamadas de sistema para gerenciamento de processos

fork

fork_exemplo.py

import os
import sys

pid = os.fork()

if pid < 0:
  sys.exit("Fork fail")

print(f"Hello world!, process_id(pid) = {os.getpid()}\n")

Hello world!, process_id(pid) = 7534
Hello world!, process_id(pid) = 7536

fork_exemplo.cpp

#include <stdio.h>
#include <unistd.h>

int main()
{
    pid = fork();
    if(pid < 0){
    perror("Fork fail");
    _exit(1);
    }
    printf("Hello world!, process_id(pid) = %d \n", getpid());
    return 0;
}

Hello world!, process_id(pid) = 685 
Hello world!, process_id(pid) = 686

Chamadas de sistema para gerenciamento de processos

waitpid

waitpid_exemplo.py

import os

i = 1
waitpid_return = ()
print(f"process_id(pid) parent= {os.getpid()}\n")

pid = os.fork()
if pid > 0:
  for i in range(1, 6):
    waitpid_return = os.waitpid(pid, os.WNOHANG)
    print(f"{i}, process_id(pid) child = {pid}, waitpid = {waitpid_return}\n")
else:
  print(f"{i}, process_id(pid) child = {pid}, waitpid = {waitpid_return}\n")

waitpid_exemplo.cpp

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int i = 1;
int pid;
int waitpid_return;
int main ()
{   
    printf("process_id(pid) parent= %d\n", getpid());
    pid = fork();
    if (pid != 0)
    {   
      
      for (int i = 1; i < 5; i++) {
        waitpid_return = waitpid(pid, NULL, WNOHANG);
        printf("%d, process_id(pid) child = %d, waitpid = %d\n", i, pid, waitpid_return);
      }
    }
    else {
        waitpid_return = waitpid(pid, NULL, WNOHANG);
        printf("%d, process_id(pid) child = %d, waitpid = %d\n", i, pid, waitpid_return);}
        return 0;
    }

Chamadas de sistema para gerenciamento de processos

execve

execve.cpp

#include <unistd.h>
#include <iostream>
#include <string>

std::string c = "/bin/ls";
std::string p = "-lh";
char *args[] = {c.data(), p.data()};
int main() {
  execve(args[0], args, NULL);
}

Chamadas de sistema para gerenciamento de diretórios

Chamadas de sistema para gerenciamento de diretórios

Exemplos

# Criar um novo diretório
mkdir mynewdir

# Remover um diretório
rmdir mynewdir

# Criar link entre arquivos
link myfile1 myfile2

# Criar link simbólico (atalho)
ln -s myfile1 myfile2

Diferenças entre links e links simbólicos¹

• Soft Links (links simbólicos): Você pode fazer links para arquivos e diretórios. Se a cópia real for excluída, o link não funcionará.
• Hard links (somente links): são apenas para arquivos; se a cópia real for excluída, o link funcionará, porque ele acessa os dados subjacentes que a cópia real estava acessando

Alguns comandos úteis

# Acessar o manual de um comando
man mkdir

# Criar um novo diretório
mkdir novapasta

# Criar um novo diretório contendo outro diretório (pasta)
mkdir -p novapasta/outrapasta

# Criar um diretório com alguma permissão definida
mkdir -m 700 novapasta

# Remover um diretório vazio
rmdir novapasta

Alguns comandos úteis

# Criar um arquivo em branco
touch meuarquivo.txt

# Criar um arquivo com algum conteúdo
echo "Ola mundo!" > meuarquivo.txt

# Adicionar uma nova linha a um arquivo existente
echo "Nova linha" >> meuarquivo.txt 

# Remover um arquivo
rm meuarquivo.txt

# Remover um diretório
rm -r novapasta

Alguns comandos úteis

# Mover arquivos
mv meuarquivo.txt /outrapasta

# Renomear arquivos
mv meuarquivo.txt novonome.txt

# Copiar arquivos
cp meuarquivo.txt copiadoarquivo.txt

# Copiar diretórios
cp -r meudiretorio outro/luga

Chamadas de sistema para gerenciamento diversos

Chamadas de sistema para gerenciamento diversos

Exemplos

# Alterar um diretório (geralmente se usa cd)
chdir <diretório existente>
cd <diretório existente>

# Define a proteção de um arquivo
chmod 700 myfile

# "Matar" um processo
kill <pid>

Proteção de um arquivo

Devo utilizar um valor octal para usuário/grupo/outros

# Permissão de escrita para o usuário (2) e nenhuma permissão para o grupo (0) e outros (0)
chmod 200 myfile
ls -l myfile

--w-------  1 thop  staff  0 27 Mar 16:18 myfile

# Permissão de leitura/escrita para o usuário (6) e permissão de leitura para o grupo (4)
chmod 640 myfile
ls -l myfile

-rw-r-----  1 thop  staff  0 27 Mar 16:18 myfile

Monolítico

• Nesta estrutura, todo o sistema operacional é implementado como um único programa de grande porte.
• Todas as funcionalidades do sistema operacional, como gerenciamento de memória, gerenciamento de processos e sistemas de arquivos, residem no kernel.
• Exemplos incluem sistemas operacionais mais antigos, como MS-DOS e versões mais antigas do UNIX.

Microkernel

• Neste modelo, o kernel é mínimo e fornece apenas as funcionalidades básicas, como gerenciamento de memória, comunicação entre processos e escalonamento de CPU.
• Funcionalidades adicionais, como sistemas de arquivos e drivers de dispositivos, são implementadas como processos de usuário que se comunicam com o kernel.
• Exemplos incluem MINIX, Symbian e Redox.

Desse modo, um erro no driver de áudio fará que o som fique truncado ou pare, mas não derrubará o computador.

Microkernel

Redox

O Redox OS segue os princípios da filosofia Unix, integrando conceitos de microkernel. Isso significa que o núcleo do sistema apenas gerencia interações entre processos e recursos, enquanto funcionalidades adicionais são movidas para bibliotecas externas, que podem ser usadas tanto pelo kernel quanto por aplicativos de usuários. Um dos grandes diferenciais é que todos os drivers são executados no espaço de usuário, em ambientes isolados, o que aumenta a segurança e a estabilidade do sistema.¹

Híbrido

• Esta abordagem combina elementos do kernel monolítico e do microkernel.
• O kernel contém algumas funcionalidades essenciais, como gerenciamento de memória e escalonamento de processos, enquanto outras funcionalidades são implementadas como módulos do kernel ou como processos de usuário.
• Exemplos incluem Linux, Windows NT/2000/XP/Vista/7/8/10.

Sistemas Virtuais

• Esta estrutura cria uma máquina virtual que simula uma arquitetura de hardware para cada processo.
• Cada processo tem a ilusão de que possui seu próprio sistema operacional.
• Exemplos incluem máquinas virtuais como VMware, VirtualBox e Hyper-V.

Contador de Programa e Registrador de Instruções

Contador de Programa e Registrador de Instruções

Processos

• Um processo é apenas uma instância de um programa em execução, incluindo os valores atuais do contador do programa, registradores e variáveis.
• Processos podem ser criados e terminados dinamicamente.
• Cada processo tem seu próprio espaço de endereçamento.

O modelo de processo

1. Vemos um computador multiprogramando quatro programas na memória (com contador programa físico).
2. Vemos quatro processos, cada um com seu próprio fluxo de controle e sendo executado independente dos outros (contador de programa lógico).
3. Vemos que, analisados durante um intervalo longo o suficiente, todos os processos tiveram progresso, mas a qualquer dado instante apenas um está sendo de fato executado.

Em qualquer sistema de multiprogramação, a CPU muda de um processo para outro rapidamente, executando cada um por dezenas ou centenas de milissegundos, dando a ilusão do paralelismo.

Criação de processos

Sistemas operacionais precisam de alguma maneira criar processos.

Quatro eventos principais fazem com que os processos sejam criados:

Criação de processos

child.sh

#!/bin/bash
sleep infinity

parent.sh

#!/bin/bash
./child.sh &
sleep infinity

$

parent.sh &

$

pgrep -P <parent pid>
pgrep -lP <parent pid>
pstree -p <parent pid>
ps --ppid <parent pid>
ls /proc/<parent pid>/task
cat /proc/<parent pid>/task/<parent pid>/children

Término de processos

Hierarquias de processos

$

./grandparent.sh
ps -efj | egrep "PGID|children|parent"
kill -9 -<pgid>

grandparent.sh

#!/bin/bash
bash parent.sh &
bash parent.sh &
for i in {1..100}; do 
sleep 2; 
echo -n "This is the grandparent process $i"; 
done

parent.sh

#!/bin/bash
bash children.sh &
bash children.sh &
for i in {1..100}; do sleep 2; echo -n "This is the parent process $i"; 
done

children.sh

#!/bin/bash
for i in {1..100}; do 
sleep 2; 
echo -n "This is a test in children process $i"; 
done

Estados de processos

$

curl -s https://openbible.com/textfiles/kjv.txt | \
grep "Exodus\s2" | \
head -4

Estados de processos

Estados de processos

O nível mais baixo de um sistema operacional estruturado em processos controla interrupções e escalonamento. Acima desse nível estão processos sequenciais.

O escalonamento, isto é, decidir qual processo deve ser executado, quando e por quanto tempo, é um assunto importante; nós o examinaremos mais adiante neste capítulo. Muitos algoritmos foram desenvolvidos para tentar equilibrar as demandas concorrentes de eficiência para o sistema como um todo e justiça para os processos individuais.

Implementação de processos

Para implementar o modelo de processos, o sistema operacional mantém uma tabela (um arranjo de estruturas) chamada de tabela de processos, com uma entrada para cada um deles.

Comando top

Com o comando top podemos ter várias informações sobre os processos:

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND                              
 2153 root      20   0  192020  50716  10752 S   1.3  0.2   0:24.52 jupyterhub                           
  350 eee_W_3+  20   0   34760   9992   5504 S   0.3  0.0   0:00.35 vim                                  
 1050 eee_W_3+  20   0  321276  68720  16192 S   0.3  0.2   0:01.28 jupyterhub-sing                      
 1072 eee_W_3+  20   0  856432  67460  14456 S   0.3  0.2   0:00.67 python3.11                           
 1202 mysql     20   0 1944024 172192  19812 S   0.3  0.5   1:11.94 mysqld                               
 1824 root      20   0 1510756  22280  13592 S   0.3  0.1   0:52.81 docker-containe                      
 2403 root      20   0 3286184  53932  19520 S   0.3  0.2   0:17.24 tty.js                               
 2964 root      20   0 1238252  40832  14912 S   0.3  0.1   1:16.43 node                                 
 3238 eee_W_3+  20   0   34736   9992   5484 S   0.3  0.0   0:00.03 vim                                      

• PID: identificador do processo
• USER: usuário
• %CPU: percentual de CPU utilizado
• %MEM: percentual de memória utilizado
• COMMAND: comando que deu origem ao processo

Comando top

Na parte do cabeçário da saída do comando são apresentadas estas informações:

top - 13:21:02 up  8:36,  0 users,  load average: 0.21, 0.22, 0.25
Tasks: 583 total,   1 running, 581 sleeping,   0 stopped,   1 zombie
%Cpu(s):  0.4 us,  0.1 sy,  0.0 ni, 99.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 32127716 total, 22673544 free,  4059152 used,  5395020 buff/cache
KiB Swap:        0 total,        0 free,        0 used. 27328092 avail Mem 

• Há 583 processos, sendo que 1 está running, 581 sleeping, 0 stopped e 1 zombie
• Sobre a CPU: 0,4% utilizado na camada de usuário (us), 0,1% na camada do kernel (sy), 99.5 não está sendo feito nada (id) e 0% esperando por I/O (wa)

Comando top

Significado dos status:

• D (sono ininterrupto): O processo está aguardando um evento, como a conclusão de uma operação de E/S, e não pode ser interrompido.
• R (em execução): O processo está sendo executado pelo processador.
• S (sono): O processo está aguardando um evento, mas pode ser interrompido por sinais.
• T (rastreado ou parado): O processo foi suspenso ou está sendo depurado.
• Z (zumbi): O processo terminou sua execução, mas ainda não foi removido da tabela de processos pelo sistema operacional.

Comando top

• top -c Mostra a linha de comando ao invés do nome do programa
• top -d <num> Atualiza a tela após num segundos
• top -p <pid> Mostra apenas o processo com o PID especificado
• top -u <user> Monitora os processos em execução de um determinado usuário

Processo zombie

Um Processo Zombie é criado quando um processo filho termina antes do processo pai e o pai não verifica o status de saída do filho.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(void)
{
    pid_t pid;
    int status;

    if ((pid = fork()) < 0) {
        perror("fork");
        exit(1);
    }

    /* Child */
    if (pid == 0)
        exit(0);

    /* Parent
     * Gives you time to observe the zombie using ps(1) ... */
    sleep(100);

    /* ... and after that, parent wait(2)s its child's
     * exit status, and prints a relevant message. */
    pid = wait(&status);
    if (WIFEXITED(status))
        fprintf(stderr, "\n\t[%d]\tProcess %d exited with status %d.\n",
                (int) getpid(), pid, WEXITSTATUS(status));

    return 0;
}

  PID TTY      STAT   TIME COMMAND
 7246 pts/49   Z      0:00 [a.out] <defunct>

Scheduling de Processos

Scheduling de Processos

Cada processo é representado, no sistema operacional, por um bloco de controle de processo (PCB - process control block) - também chamado bloco de controle de tarefa.

Fila de scheduling

Mudança de contexto

A alocação da CPU a outro processo requer a execução do salvamento do estado do processo corrente e a restauração do estado de um processo diferente. Essa tarefa é conhecida como mudança de contexto

• As interrupções fazem com que o sistema operacional tire a CPU de sua tarefa corrente para executar uma rotina do kernel.
• Essas operações ocorrem, com frequência, em sistemas de uso geral.
• O contexto é representado no PCB do processo.

Mudança de contexto

O tempo gasto na mudança de contexto é puro overhead porque o sistema não executa trabalho útil durante a permuta de processos. A velocidade da permuta varia de uma máquina para outra, dependendo da velocidade da memória, do número de registradores a serem copiados

Comunicação Interprocessos

Os processos que são executados concorrentemente no sistema operacional podem ser processos independentes ou processos cooperativos

Comunicação Interprocessos

Razões para o fornecimento de um ambiente que permita a cooperação entre processos:

Processos cooperativos

Processos cooperativos demandam um mecanismo de comunicação entre processos (IPC) que lhes permita trocar dados e informações. Há dois modelos básicos de comunicação entre processos: memória compartilhada e transmissão de mensagens.

Sistema de memória compartilhada

A comunicação entre processos que usam memória compartilhada requer que os processos em comunicação estabeleçam uma região de memória compartilhada. Normalmente, a região de memória compartilhada reside no espaço de endereçamento do processo que cria o segmento de memória compartilhada. Outros processos que queiram se comunicar usando esse segmento de memória compartilhada devem anexá-lo ao seu espaço de endereçamento.

Sistema de memória compartilhada

Condições de corrida

Sistema de memória compartilhada

Regiões críticas

Regiões críticas

Quatro condições são estabelecidas para se chegar a uma boa solução de corridas:

1. Dois processos jamais podem estar simultaneamente dentro de suas regiões críticas.
2. Nenhuma suposição pode ser feita a respeito de velocidades ou do número de CPUs.
3. Nenhum processo executando fora de sua região crítica pode bloquear qualquer processo.
4. Nenhum processo deve ser obrigado a esperar eternamente para entrar em sua região crítica.

Exclusão mútua com espera ocupada

Desabilitando interrupções

Exclusão mútua com espera ocupada

Variáveis do tipo trava

Exclusão mútua com espera ocupada

Alternância explícita

while True:
  while turn != 1:
    print("processo 0 na região crítica")
    turn = 1
    print("processo 0 na região não crítica")

while True:
  while turn != 0:
    print("processo 1 na região crítica")
    turn = 0
    print("processo 1 na região não crítica")

Exclusão mútua com espera ocupada

Solução de Peterson

Antes de usar as variáveis compartilhadas (isto é, antes de entrar na região crítica), cada processo chama enter_region com seu próprio número de processo, 0 ou 1, como parâmetro. Essa chamada fará que ele espere, se necessário, até que seja seguro entrar. Após haver terminado com as variáveis compartilhadas, o processo chama leave_region para indicar que ele terminou e para permitir que outros processos entrem, se assim desejarem.

Exclusão mútua com espera ocupada

Solução de Peterson

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import threading
import time

cs = 0
flag_0 = False
flag_1 = False
turn = 0

def thread_0():
    global cs, flag_0, flag_1, turn

    flag_0 = True
    turn = 1
    while (flag_1 and turn == 1):
            continue

    for i in range(10):
        cs += 1
        print("Thread 0: cs =", cs)
        time.sleep(0.1)

    flag_0 = False

def thread_1():
    global cs, flag_0, flag_1, turn

    flag_1 = True
    turn = 0
    while (flag_0 and turn == 0):
        continue

    for i in range(10):
        cs += 1000
        print("Thread 1: cs =", cs)
        time.sleep(0.1)

    flag_1 = False

if __name__ == "__main__":
        t0 = threading.Thread(target=thread_0)
        t1 = threading.Thread(target=thread_1)
        t0.start()
        t1.start()

# Reference: https://www.aspires.cc/implementing-peterson-algorithm-with-python/

Sistemas de Transmissão de Mensagens

A transmissão de mensagens fornece um mecanismo para permitir que os processos se comuniquem e sincronizem suas ações sem compartilhar o mesmo espaço de endereçamento. Isso é particularmente útil em um ambiente distribuído em que os processos em comunicação podem residir em diferentes computadores conectados por uma rede. Por exemplo, um programa de bate-papo na Internet poderia ser projetado de modo que os participantes se comuniquem uns com os outros trocando mensagens.

Um recurso de transmissão de mensagens fornece, pelo menos, duas operações:

• send(message)
• receive(message)

Sistemas de Transmissão de Mensagens

Sockets

Um socket é definido como uma extremidade de comunicação. Um par de processos comunicando-se por uma rede emprega um par de sockets — um para cada processo. Um socket é identificado por um endereço IP concatenado com um número de porta. Geralmente, os sockets usam uma arquitetura cliente-servidor. O servidor espera solicitações recebidas de clientes ouvindo em uma porta especificada. Uma vez que uma solicitação seja recebida, o servidor aceita uma conexão proveniente do socket do cliente para completá-la.

Sisitemas de Transmissão de Mensagens

server.py

import socket


def run_server():
    # create a socket object
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server_ip = "127.0.0.1"
    port = 8000

    # bind the socket to a specific address and port
    server.bind((server_ip, port))
    # listen for incoming connections
    server.listen(0)
    print(f"Listening on {server_ip}:{port}")

    # accept incoming connections
    client_socket, client_address = server.accept()
    print(f"Accepted connection from {client_address[0]}:{client_address[1]}")

    # receive data from the client
    while True:
        request = client_socket.recv(1024)
        request = request.decode("utf-8") # convert bytes to string
        
        # if we receive "close" from the client, then we break
        # out of the loop and close the conneciton
        if request.lower() == "close":
            # send response to the client which acknowledges that the
            # connection should be closed and break out of the loop
            client_socket.send("closed".encode("utf-8"))
            break

        print(f"Received: {request}")

        response = "accepted".encode("utf-8") # convert string to bytes
        # convert and send accept response to the client
        client_socket.send(response)

    # close connection socket with the client
    client_socket.close()
    print("Connection to client closed")
    # close server socket
    server.close()


run_server()

client.py

import socket


def run_client():
    # create a socket object
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server_ip = "127.0.0.1"  # replace with the server's IP address
    server_port = 8000  # replace with the server's port number
    # establish connection with server
    client.connect((server_ip, server_port))

    while True:
        # input message and send it to the server
        msg = input("Enter message: ")
        client.send(msg.encode("utf-8")[:1024])

        # receive message from the server
        response = client.recv(1024)
        response = response.decode("utf-8")

        # if server sent us "closed" in the payload, we break out of the loop and close our socket
        if response.lower() == "closed":
            break

        print(f"Received: {response}")

    # close client socket (connection to the server)
    client.close()
    print("Connection to server closed")

run_client()

Exemplo extraído daqui

Threads, miniprocessos

Por que alguém iria querer ter um tipo de processo dentro de um processo? Na realidade, há várias razões para a existência desses miniprocessos, chamados threads

Um processador de texto com três threads

Um processador de texto com três threads

Deve ficar claro que ter três processos em separado não funcionaria aqui, pois todos os três threads precisam operar no documento. Ao existirem três threads em vez de três processos, eles compartilham de uma memória comum.

O modelo de thread clássico

Threads POSIX

Executando Threads

multiple_threads.py

"""
Executando Múltiplas Threads

https://realpython.com/intro-to-python-threading/
"""

import logging
import threading
import time

def thread_function(name):
    logging.info("Thread %s: starting, ID: %s", name, threading.get_native_id())
    time.sleep(2)
    logging.info("Thread %s: finishing", name)

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    threads = list()
    for index in range(3):
        logging.info("Main    : create and start thread %d.", index)
        x = threading.Thread(target=thread_function, args=(index,))
        threads.append(x)
        x.start()

    for index, thread in enumerate(threads):
        logging.info("Main    : before joining thread %d.", index)
        thread.join()
        logging.info("Main    : thread %d done", index)

Convertendo de um thread para multithread

Conflitos entre threads sobre o uso de uma variável global

Scheduling ou escalonamento de CPU

Quando um computador é multiprogramado, ele frequentemente tem múltiplos processos ou threads competindo pela CPU ao mesmo tempo. Essa situação ocorre sempre que dois ou mais deles estão simultaneamente no estado de pronto. Se apenas uma CPU está disponível, uma escolha precisa ser feita sobre qual qual processo será executado. A parte do sistema operacional que faz esta escolha é escalonador.

Comportamento do processo

Quase todos os processos alternam entre períodos de computação intensa e solicitações de E/S (disco ou rede). A CPU executa cálculos por um tempo contínuo, até ser necessário realizar uma chamada de sistema para ler ou gravar em um arquivo. Após a conclusão dessa chamada, a CPU retoma os cálculos até que precise de mais dados ou precise gravar mais informações, repetindo o ciclo..

Ciclo de Picos de CPU e I/O

O sucesso do scheduling da CPU depende de uma propriedade observada nos processos: a execução de processos consiste em um ciclo de execução da CPU e espera por I/O. Os processos se alternam entre esses dois estados. A execução do processo começa com um pico de CPU. Esse é seguido por um pico de I/O, que é seguido por outro pico de CPU e, então, outro pico de I/O, e assim por diante. Eventualmente, o último pico de CPU termina com o sistema solicitando o encerramento da execução

Scheduler da CPU

Sempre que a CPU se torna ociosa, o sistema operacional deve selecionar um dos processos na fila de prontos para ser executado. O processo de seleção é realizado pelo scheduler da CPU. O scheduler seleciona um processo entre os processos na memória que estão prontos para execução e aloca a CPU a esse processo.

Scheduling com Preempção (interrupção forçada de um processo)

Decisões de scheduling da CPU podem ser tomadas sob as seguintes circunstâncias:

1. Quando um processo passa do estado de execução para o estado de espera por exemplo, como resultado de uma solicitação de I/O ou de uma invocação a wait para o encerramento de um processo-filho
2. Quando um processo passa do estado de execução para o estado de pronto (por exemplo, quando ocorre uma interrupção)
3. Quando um processo passa do estado de espera para o estado de pronto (por exemplo, na conclusão de I/O)
4. Quando um processo termina

Scheduling com Preempção

Nas situações 1 e 4, não há alternativa no que diz respeito ao scheduling. Um novo processo (se existir um na fila de prontos) deve ser selecionado para execução. Há uma alternativa, no entanto, nas situações 2 e 3.

Quando o scheduling ocorre apenas sob as circunstâncias 1 e 4, dizemos que o esquema de scheduling é sem preempção ou cooperativo. Caso contrário, ele tem preempção.

Despachante

Outro componente envolvido na função de scheduling da CPU é o despachante. O despachante é o módulo que passa o controle da CPU ao processo selecionado pelo scheduler. Essa função envolve o seguinte:

• Mudança de contexto
• Mudança para a modalidade de usuário
• Salto para o local apropriado no programa do usuário para reiniciar o programa

O tempo que o despachante leva para interromper um processo e iniciar a execução de outro é conhecido como latência do despacho.

Algoritmos de Scheduling

Scheduling “Primeiro-a-Chegar, Primeiro-a-Ser-Atendido”

O algoritmo mais simples de scheduling da CPU é o algoritmo “primeiro-a-chegar, primeiro-a-ser-atendido” (FCFS – first-come, first-served).

• Nesse esquema, o processo que solicita a CPU primeiro é o primeiro a usá-la.
• Quando um processo entra na fila de prontos, seu PCB é conectado na cauda da fila. Quando a CPU está livre, ela é alocada ao processo na cabeça da fila.
• O lado negativo é que o tempo médio de espera na política FCFS geralmente é bem longo.

gantt
    title Primeiro-a-Chegar, Primeiro-a-Ser-Atendido 
    dateFormat  SS
    axisFormat %SS
    tickInterval 1second
    P1: p1, 0, 24s
    P2: p2, after p1, 3s
    P3: after p2, 3s

Algoritmos de Scheduling

Scheduling Menor-Job-Primeiro

Esse algoritmo associa a cada processo a duração do próximo pico de CPU do processo. Quando a CPU está disponível, ela é atribuída ao processo que tem o próximo pico de CPU mais curto

gantt
    title Menor-Job-Primeiro
    dateFormat  SS
    axisFormat %SS
    tickInterval 1second
    P4: p4, 0, 3s
    P1: p1, after p4, 6s
    P3: p3, after p1, 7s
    P2: p2, after p3, 8s

Algoritmos de Scheduling

Scheduling por Prioridades

Uma prioridade é associada a cada processo, e a CPU é alocada ao processo com a prioridade mais alta. Processos com prioridades iguais são organizados no schedule em ordem FCFS. O algoritmo SJF é simplesmente um algoritmo por prioridades em que a prioridade (p) é o inverso do próximo pico de CPU (previsto). Quanto maior o pico de CPU, menor a prioridade, e vice-versa.

gantt
    title Scheduling por Prioridades (p)
    dateFormat  SS
    axisFormat %SS
    tickInterval 1second
    P2 (1): p2, 0, 1s
    P5 (2): p5, after p2, 5s
    P1 (3): p1, after p5, 10s
    P3 (4): p3, after p1, 2s
    P4 (5): p4, after p3, 1s

Algoritmos de Scheduling

Scheduling Round-Robin

O scheduler da CPU seleciona o primeiro processo da fila de prontos, define um timer com interrupção após 1 quantum de tempo e despacha o processo.

Portanto, uma entre duas coisas ocorrerá. O processo pode ter um pico de CPU menor do que 1 quantum de tempo. Nesse caso, o próprio processo liberará a CPU voluntariamente. O scheduler passará então para o próximo processo na fila de prontos. Se o pico de CPU do processo em execução corrente for maior do que 1 quantum de tempo, o timer será desligado e causará uma interrupção para o sistema operacional. Uma mudança de contexto será executada e o processo será inserido na cauda da fila de prontos. O scheduler da CPU selecionará então o próximo processo na fila de prontos.

gantt
    title Round-Robin
    dateFormat  SS
    axisFormat %SS
    tickInterval 1second
    P1: p1, 0, 4s
    P2: p2, after p1, 3s
    P3: p3, after p2, 3s
    P1: p11, after p3, 4s
    P1: p12, after p11, 4s
    P1: p13, after p12, 4s
    P1: p14, after p13, 4s

Gerenciamento de memória

O que todo programador gostaria é de uma memória privada, infinitamente grande e rápida, que fosse não volátil também, isto é, não perdesse seus conteúdos quando faltasse energia elétrica. Aproveitando o ensejo, por que não torná-la barata, também? Infelizmente, a tecnologia ainda não produz essas memórias no momento.

Hierarquia de memória

Ao longo dos anos, as pessoas descobriram o conceito de hierarquia de memórias, em que os computadores têm alguns megabytes de memória cache volátil, cara e muito rápida, alguns gigabytes de memória principal volátil de velocidade e custo médios, e alguns terabytes de armazenamento em disco em estado sólido ou magnético não volátil, barato e lento, sem mencionar o armazenamento removível, com DVDs e dispositivos USB. É função do sistema operacional abstrair essa hierarquia em um modelo útil e então gerenciar a abstração.

A parte do sistema operacional que gerencia (parte da) hierarquia de memórias é chamada de gerenciador de memória.

A noção de um espaço de endereçamento

Dois problemas têm de ser solucionados para permitir que múltiplas aplicações estejam na memória ao mesmo tempo sem interferir umas com as outras: proteção e realocação.

Uma solução foi inventar uma nova abstração para a memória: o espaço de endereçamento. Da mesma forma que o conceito de processo cria uma espécie de CPU abstrata para executar os programas, o espaço de endereçamento cria uma espécie de memória abstrata para abrigá-los. Um espaço de endereçamento é o conjunto de endereços que um processo pode usar para endereçar a memória. Cada processo tem seu próprio espaço de endereçamento, independente daqueles pertencentes a outros processos (exceto em algumas circunstâncias especiais onde os processos querem compartilhar seus espaços de endereçamento).

Registradores base e registradores limite

Registradores base e registradores limite

Troca de processos (Swapping)

Troca de processos (Swapping)

Mudanças na alocação de memória à medida que processos entram nela e saem dela. As regiões sombreadas são regiões não utilizadas da memória:

Gerenciamento de memória com mapas de bits ou listas encadeadas

Gerenciamento de memória com listas encadeadas

Uma maneira de controlar o uso da memória é manter uma lista encadeada de espaços livres e de segmentos de memória alocados, onde um segmento contém um processo ou é um espaço vazio entre dois processos.

Algoritmos:

• first fit (procura fazer a menor busca possível);
• next fit (uma pequena variação do first fit, exceto por memorizar a posição que se encontra um espaço livre adequado sempre que o encontra);
• best fit (faz uma busca em toda a lista, do início ao fim, e escolhe o menor espaço livre que seja adequado);
• worst fit (sempre escolhe o maior espaço livre);
• quick fit (mantém listas em separado para alguns dos tamanhos mais comuns solicitados).

Memória virtual

Apesar de os tamanhos das memórias aumentarem depressa, os tamanhos dos softwares estão crescendo muito mais rapidamente.

Como consequência desses desenvolvimentos, há uma necessidade de executar programas que são grandes demais para se encaixar na memória e há certamente uma necessidade de ter sistemas que possam dar suporte a múltiplos programas executando em simultâneo, cada um deles encaixando-se na memória, mas com todos coletivamente excedendo-a.

Memória virtual

Tabelas de página

O objetivo da tabela de páginas é mapear as páginas virtuais em quadros de páginas.

• Estrutura de uma entrada da tabela de páginas:

• O campo mais importante é o número do quadro de página. Afinal, a meta do mapeamento de páginas é localizar esse valor.
• A informação presente/ausente, se for 1 a entrada pode ser usada, se for 0 a pagina virtual não está na memória
• A proteção diz que tipos de acessos são permitidos
• Modificada se refere a uma página que foi atualizada e indica se precisa alterar em disco
• Referenciada é se uma página esta sendo usada ou para leitura ou para escrita

TLB (Translation Lookaside Buffers) ou memória Associativa

Pequeno dispositivo de hardware para mapear endereços virtuais para endereços físicos sem ter de passar pela tabela de páginas.

Sistemas de Arquivos

Arquivos são gerenciados pelo sistema operacional. Como um todo, aquela parte do sistema operacional lidando com arquivos é conhecida como sistema de arquivos.

Um arquivo fornece uma maneira para armazenar informações sobre o disco e lê-las depois. Isso deve ser feito de tal modo que isole o usuário dos detalhes de como e onde as informações estão armazenadas.

Tipos de arquivos

O UNIX e o Windows, por exemplo, apresentam arquivos regulares e diretórios. O UNIX também tem arquivos especiais de caracteres e blocos.

• Arquivos regulares são aqueles que contêm informações do usuário.
• Diretórios são arquivos do sistema para manter a estrutura do sistema de arquivos.
• Arquivos especiais de caracteres são relacionados com entrada/saída e usados para modelar dispositivos de E/S seriais como terminais, impressoras e redes.
• Arquivos especiais de blocos são usados para modelar discos.

Tipos de arquivos

Arquivos regulares geralmente são arquivos ASCII ou arquivos binários. Arquivos ASCII consistem de linhas de texto.

• ASCII: Código Padrão Americano para o Intercâmbio de Informação é um sistema de representação de letras, algarismos e sinais de pontuação e de controle
• A grande vantagem dos arquivos ASCII é que eles podem ser exibidos e impressos como são e editados com qualquer editor de texto. Além disso, se grandes números de programas usam arquivos ASCII para entrada e saída, é fácil conectar a saída de um programa com a entrada de outro, como em pipelines do interpretador de comandos (shell)
• Outros arquivos são binários, o que apenas significa que eles não são arquivos ASCII. Listá-los em uma impressora resultaria em algo completamente incompreensível. Em geral, eles têm alguma estrutura interna conhecida pelos programas que os usam.

Atributos de arquivos

Operações com arquivos

1. Create touch ou echo 'algum texto' > arquivo.txt
2. Delete rm arquivo.txt
3. Open
4. Close
5. Read
6. Write
7. Append echo 'algum outro texto' >> arquivo.txt
8. Get attributes
9. Set attributes chmod 640 arquivo.txt
10. Rename mv antigo novo

Diretórios

Para controlar os arquivos, sistemas de arquivos normalmente têm diretórios ou pastas, que são em si arquivos. Nesta seção discutiremos diretórios, sua organização, suas propriedades e as operações que podem ser realizadas por eles.

A capacidade dos usuários de criarem um número arbitrário de subdiretórios proporciona uma ferramenta de estruturação poderosa para eles organizarem o seu trabalho. Por essa razão, quase todos os sistemas de arquivos modernos são organizados dessa maneira.

Operações com diretórios

1. Create mkdir pasta
2. Delete rmdir pasta
3. Opendir
4. Closedir
5. Readdir
6. Rename mv antigo novo
7. Link link arquivo nome_link
8. Unlink unlink nome_link

Gerenciamento e otimização de sistemas de arquivos

O gerenciamento de espaço de disco é uma preocupação importante para os projetistas de sistemas de arquivos. Duas estratégias gerais são possíveis para armazenar um arquivo de n bytes: ou são alocados n bytes consecutivos de espaço, ou o arquivo é dividido em uma série de blocos (não necessariamente) contíguos.

Como vimos, armazenar um arquivo como uma sequência contígua de bytes tem o problema óbvio de que se um arquivo crescer, ele talvez tenha de ser movido dentro do disco. O mesmo problema ocorre para segmentos na memória, exceto que mover um segmento na memória é uma operação relativamente rápida em comparação com mover um arquivo de uma posição no disco para outra.

Gerenciamento e otimização de sistemas de arquivos

Feita a opção de armazenar arquivos em blocos de tamanho fixo, devemos decidir qual tamanho o bloco terá.

• Ter um tamanho de bloco grande significa que todos os arquivos, mesmo um de 1 byte, ocuparão um bloco inteiro. Também significa que arquivos pequenos desperdiçam uma grande quantidade de espaço de disco.
• Por outro lado, um tamanho de bloco pequeno significa que a maioria dos arquivos ocupará múltiplos blocos e, desse modo, precisará de múltiplas buscas e atrasos rotacionais para lê-los, reduzindo o desempenho.
• Então, se a unidade de alocação for grande demais, desperdiçamos espaço; se ela for pequena demais, desperdiçamos tempo.

Monitoramento dos blocos livres

Sistemas de I/O

As duas tarefas principais de um computador são I/O e processamento. Em muitos casos, a principal tarefa é o I/O, e o processamento é meramente incidental. Por exemplo, quando navegamos em uma página da web ou editamos um arquivo, nosso interesse imediato é ler ou dar entrada em alguma informação, e não computar uma resposta.

Hardware de I/O

Hardware de I/O

Hardware de I/O

Hardware de I/O

Como o processador pode fornecer comandos e dados a um controlador para realizar uma transferência de I/O?

Hardware de I/O

Alternativamente, o controlador do dispositivo pode suportar I/O mapeado para a memória.

Nesse caso, os registradores de controle do dispositivo são mapeados para o espaço de endereçamento do processador. A CPU executa solicitações de I/O usando as instruções-padrão de transferência de dados para ler e gravar os registradores de controle de dispositivos em suas locações mapeadas na memória física.

Interface de I/O da Aplicação

Infelizmente para os fabricantes de hardware de dispositivos, cada tipo de sistema operacional tem seus próprios padrões para a interface dos drivers de dispositivos.

Instalação via WSL

Abra o PowerShell e execute

PowerShell

wsl --install

Por padrão será instalada a distribuição Ubuntu.

Caso queira instalar uma outra distribuição adcione o argumento -d e o nome da distribuição

PowerShell

wsl --install -d <nome da distribuição>

Configuração do ambiente

• Após a instalação será necessário definir um usuário e uma senha
• Caso você não seja o administrador da máquina, será necessária algumas configurações adicionais:

No PowerShell execute o comando para poder acessar o usuário root:

PowerShell

wsl --install -d <nome da distribuição> -u <nome do usuário>

Por exemplo caso tenha instalado o Debian, será -d Debian

• Adicionar o seu usuário no sudoers para ter acesso a alguns privilégios

No terminal do linux digitar o comando

$

usermod -aG sudo <nome do usuário>

Instalando programas

Nas distribuições derivadas do Debian o gerenciador de pacotes é o apt

• Para instalar o programa cmatrix

$

sudo apt install cmatrix

Para executar escreva cmatrix no terminal

$

cmatrix

Erros que podem surgir na instalação

Comandos que podem ser executados para solucionar erros de instalação

sudo apt install <nome do pacote> --fix-missing

sudo apt update
sudo apt --fix-broken install
sudo apt install <nome do pacote>

Alguns programas úteis

• neovim editor de código
• g++ compilador de código c++
• tmux permite que várias sessões de terminal sejam acessadas simultaneamente em uma única janela
• wget permite fazer download de conteúdos da web

Para instalar todos eles de uma vez

$

sudo apt install neovim g++ tmux wget

Comandos básicos do neovim

• Para instalar: sudo apt install neovim
• Para iniciar digite nvim

Comandos básicos do neovim

Para iniciar no modo de -- INSERÇÃO -- ou -- INSERT --, clique na letra i

Assim será possível digitar

Comandos básicos do neovim

– Após digitar, você deve sair do modo -- INSERÇÃO -- clicando em ESC

– Para salvar o arquivo digite : e em seguida w script.sh

– Clicando na tecla ENTER o arquivo está salvo com o nome script.sh

– Para sair é só digitar :, depois q e então a tecla ENTER

Comandos básicos do neovim

Comandos básicos do tmux

• Instalar sudo apt install tmux e para executar tmux
• Arquivo de configuração .tmux.conf pode ser alterado e salvo em /home/usuario
• Exemplo de um arquivo de configuração aqui
• O prefixo foi alterado para ctrl + a
• A divisão vertical ctrl + b e -; a divisão horizontal ctrl + b e \

Comandos básicos do tmux

– Para dividir a janela horizontalmente com ctrl + a \

– Para dividir a janela verticalmente com ctrl + a -

– Para criar nova janela com ctrl + a c

Como o Docker funciona?

A tecnologia Docker usa o kernel do Linux e funcionalidades do kernel, como cGroups e namespaces, para segregar processos. Assim, eles podem ser executados de maneira independente. O objetivo dos containers é criar independência: a habilidade de executar diversos processos e apps separadamente para utilizar melhor a infraestrutura e, ao mesmo tempo, manter a segurança que você teria em sistemas separados.

• cGroups: Você pode usar control groups (cgroups) para estabelecer limites, priorizar ou controlar o acesso aos recursos de hardware para grupos de processos. Isto permite que você controle granularmente o uso de recursos de aplicações para utilizá-los de forma mais eficiente.
• namespaces: No contexto dos contêineres, isso significa que usuários e grupos podem ter privilégios para determinadas operações dentro do contêiner sem ter esses privilégios fora do contêiner. (Em outras palavras, o conjunto de capacidades de um processo para operações dentro de um namespace de usuário pode ser bem diferente de seu conjunto de capacidades no sistema host.)

Instalação do docker em um ambiente Debian

Para instalação do docker usando apt

https://docs.docker.com/engine/install/debian/#install-using-the-repository

Puxar uma imagem de um registro

Um registro (registry) de contêiner é um repositório — ou coleção de repositórios — usado para armazenar e acessar imagens de container.

Os registros de containeres economizam um tempo valioso dos desenvolvedores na criação e entrega de aplicativos nativos da nuvem, agindo como intermediários para o compartilhamento de imagens de contêineres entre sistemas.

docker pull alpine

Executar um container

Para processos interativos (como um shell), você deve usar os parâmetros -i -t juntos para alocar um tty (terminal) para o container.

docker run -it alpine

Site oficial da distribuição Alpine Linux: https://www.alpinelinux.org/

• Gerenciador de pacotes (apk)
• Para instalar apk add cmatrix

Imagens com programas já configurados

Python com um Debian mínimo

Para puxar a imagem

docker pull python:3.12.3-slim-bullseye

Para executar a imagem

docker run -it python:3.12.3-slim-bullseye

Para abrir o shell deste container seguir estes passos

1. Executar o container: docker run -it python:3.12.3-slim-bullseye
2. Verificar qual o ID do container que está em execução: docker container ls
3. Executar o comando para acessar o terminal: docker exec -it <CONTAINER ID> bash

Verificando o tamanho das imagens

docker image ls

REPOSITORY                TAG                   IMAGE ID      CREATED       SIZE
docker.io/library/alpine  latest                442043f030d3  6 days ago    9.12 MB
docker.io/library/python  3.12.3-slim-bullseye  d8ed415581d3  7 weeks ago   127 MB

Criação de um Dockerfile

Dockerfile nada mais é do que um meio que utilizamos para criar nossas próprias imagens.

Dockerfile

FROM alpine # utilização de uma imagem base
RUN apk add cmatrix # execução de comandos na etapa de build
CMD cmatrix # execução de comandos na etapa de inicialização do container

Outros comandos

• COPY src src compiar uma pasta local de nome src para dentro da imagem
• A lista completa poderá ser visualizada aqui https://docs.docker.com/reference/dockerfile/

Usar o comando: docker build -t alpine-new para recriar a imagem a partir das alterações no Dockerfile

Dockerhub

Como mencionado anteriormente, quando baixamos uma image usando pull, estamos obtendo esta imagem de um registry que no caso do docker o padrão é o dockerhub. Para logar neste registro e poder enviar as nossas próprias imagens (push), devemos utilizar o comando docker login -u <user> -p <password> e em seguida docker push <tag>.

Criação do EC2 e instalação do Docker

Conectar o VSCode no EC2