Se você está montando um PC, podem ter perguntado a você como desejava instalar seu sistema operacional – MBR ou GPT?

As diferenças entre uma partição MBR e GPT são bastante diretas. Porém, há muitas informações básicas que o ajudarão a ter uma ideia mais clara sobre cada tipo de tabela de partição e quando você deve escolher uma em detrimento da outra.

Neste artigo, abordaremos o que é uma partição, a diferença entre uma partição MBR e GPT, se você deve atualizar de um tipo de partição para outro e muito mais.

O que é uma partição?

Uma partição é uma divisão virtual de uma unidade de disco rígido (em inglês, hard disk drive ou HDD) ou unidade de estado sólido (em inglês, solid state drive ou SSD). Cada partição pode variar em tamanho e, normalmente, cumpre uma função diferente.

Por exemplo, no Windows geralmente há uma pequena partição de recuperação e uma grande partição de sistema de arquivos denominada C:. A partição C: é o que a maioria das pessoas conhece, pois é onde você geralmente instala seus programas e armazena seus vários arquivos.

No Linux, normalmente há uma partição raiz (/), uma para swap – que ajuda no gerenciamento de memória – e uma grande partição /home. A partição /home é semelhante à partição C: no Windows, pois é onde você instala a maioria dos seus programas e armazena arquivos.

Se você comprou seu computador em uma loja e o sistema operacional já está instalado, o fabricante já cuidou das partições. Você não precisa se preocupar com elas, a menos que queira fazer algo como dual-boot de Windows e Linux a partir do mesmo HDD ou SDD.

Mesmo que você mesmo esteja instalando o sistema operacional, na maioria das vezes, o instalador vai sugerir partições e tamanhos de partição padrão.

Novamente, você geralmente não precisa fazer nenhum ajuste.

Agora que você tem uma visão geral de alto nível do que é uma partição, podemos nos aprofundar nas diferenças entre as partições MBR e GPT.

Observação: usarei o termo "unidade" para me referir a HDDs e SSDs de agora em diante.

Uma visão geral de partições MBR e GPT

Antes que uma unidade possa ser dividida em partições individuais, ela precisa ser configurada para usar um esquema ou tabela de partição específica.

Uma tabela de partições informa ao sistema operacional como as partições e os dados na unidade são organizados. Por exemplo, as capturas de tela acima mostram as tabelas de partição na unidade e cada partição individual é mostrada como um bloco retangular.

Existem dois tipos principais de tabelas de partição: MBR e GPT.

MBR significa Master Boot Record (em português, registro mestre de inicialização) e é um pouco de espaço reservado no início da unidade que contém as informações sobre como as partições são organizadas. O MBR também contém o código para iniciar o sistema operacional e, às vezes, é chamado de Boot Loader (em português, carregador de inicialização).

GPT é uma abreviação de GUID Partition Table (em português, tabela de partição GUID) e é um padrão mais recente que está substituindo lentamente o MBR.

Ao contrário de uma tabela de partição MBR, o GPT armazena os dados sobre como todas as partições são organizadas e como inicializar o sistema operacional em toda a unidade. Desse modo, se uma partição for apagada ou corrompida, ainda será possível inicializar e recuperar alguns dos dados.

Se você comprou seu computador nos últimos cinco anos, é muito provável que ele esteja usando tabelas de partição GPT em vez das tabelas MBR mais antigas.

Diferenças entre as partições MBR e GPT

Existem várias diferenças entre as partições MBR e GPT, mas abordaremos algumas das principais aqui.

Primeiro, a capacidade máxima das tabelas de partição MBR é de apenas 2 terabytes. Você pode usar uma unidade com mais de 2 terabytes com MBR, mas apenas os primeiros 2 terabytes da unidade serão usados. O restante do armazenamento na unidade será desperdiçado.

Por outro lado, as tabelas de partição GPT oferecem uma capacidade máxima de 9,7 zetabytes. 1 zetabyte é cerca de 1 bilhão de terabytes. Então, é improvável que você fique sem espaço tão cedo.

Em seguida, as tabelas de partição MBR podem ter no máximo 4 partições separadas. No entanto, uma dessas partições pode ser configurada para ser uma partição estendida, que é uma partição que pode ser dividida em 23 partições adicionais. Portanto, o número máximo absoluto de partições que uma tabela de partições MBR pode ter é de 26 partições.

As tabelas de partição GPT permitem até 128 partições separadas, o que é mais do que suficiente para a maioria das aplicações do mundo real.

Como o MBR é mais antigo, geralmente vem junto com sistemas BIOS legados mais antigos, enquanto o GPT é encontrado em sistemas UEFI mais recentes. Isso significa que as partições MBR têm melhor compatibilidade de software e hardware, embora o GPT esteja começando a alcançá-lo.

Daremos uma breve olhada no BIOS legado e no UEFI um pouco mais adiante neste artigo.

Você deve atualizar de MBR para GPT?

Se uma de suas unidades estiver usando uma tabela de partição MBR, você pode estar se perguntando se deve atualizar para o padrão GPT mais recente.

Resumindo, provavelmente, não. Como diz o ditado, se não está quebrado, não conserte.

É muito fácil arruinar o setor MBR da unidade, impossibilitando a inicialização novamente. Você precisará criar uma unidade USB de recuperação com Windows ou Linux e tentar reparar o MBR ou limpar completamente a unidade e reinstalar o sistema operacional.

Falo isso por experiência própria: não vale a dor de cabeça.

Dito isso, há alguns casos em que você pode considerar atualizar de MBR para GPT.

Por exemplo, talvez você queira atualizar sua unidade para uma com mais de 2 terabytes ou precise de mais de 26 partições. Mesmo nesses casos, você precisará certificar-se de que seu hardware pode suportar uma tabela de partições GPT e um BIOS UEFI.

Se você fez a pesquisa e tem certeza de que deseja passar a usar o GPT, certifique-se de ter um backup de sua unidade e de todos os dados importantes. Na pior das hipóteses, você poderá reverter sem precisar reinstalar tudo e começar do zero.

Uma visão geral do BIOS

Eu mencionei o BIOS algumas vezes antes. Embora esteja um pouco fora do escopo deste artigo, é necessário um entendimento básico do BIOS para entender uma das diferenças principais entre as partições MBR e GPT.

BIOS significa Basic Input/Output System (em português, Sistema Básico de Entrada/Saída) e é o software armazenado em um chip na placa-mãe de um computador que é executado quando você o liga pela primeira vez.

O BIOS faz coisas como configurar o teclado, mouse e outros hardwares, definir o relógio do sistema, testar a memória e assim por diante. Em seguida, ele procura uma unidade e inicia o boot loader (carregador de inicialização) na unidade, que é uma tabela de partição MBR ou GPT.

Normalmente, quando você liga o computador pela primeira vez, verá um logotipo do fabricante do computador ou da placa-mãe.

Muitas vezes, há uma mensagem abaixo do logotipo dizendo qual tecla pressionar para configurar o BIOS do computador. Essa tecla geralmente é Delete (ou Del), Escape (ou ESC) ou F2, embora varie de acordo com o fabricante.

Conforme mencionado anteriormente, existem dois tipos principais de BIOS – BIOS legado e BIOS UEFI:

BIOS legados são mais antigos e são totalmente controlados por teclado. Eles geralmente são simples em termos de interface do usuário e têm uma cor de fundo preta ou azul semelhante à tela preta/azul da morte do Windows.

UEFI significa Unified Extensible Firmware Interface (em português, Interface Unificada de Firmware Extensível) e pode ser considerado um tipo mais recente de BIOS. O UEFI geralmente inclui gráficos para mostrar a velocidade da ventoinha, temperatura e velocidades de clock da CPU e, às vezes, pode ser controlado com um mouse ou trackpad.

BIOS de MBR e GPT

Como o MBR é um padrão mais antigo, ele é emparelhado com os sistemas BIOS legados (e o BIOS legado só pode acessar unidades com uma partição MBR). Isso não é necessariamente ruim, pois o suporte para BIOS legado é melhor.

Novamente, contudo, uma das limitações mais óbvias das partições MBR é que ela só pode lidar com unidades de até 2 terabytes.

O padrão GPT mais recente é emparelhado com sistemas BIOS UEFI. Embora o suporte para GPT e BIOS UEFI não seja tão bom quanto MBR/BIOS legado, ele está ganhando terreno.

Mais fabricantes estão migrando para BIOS UEFI, que, por sua vez, exige que as unidades usem o formato GPT mais recente. No entanto, o requisito para unidades formatadas em GPT vem com a vantagem de uma capacidade muito maior e até 128 partições.

Para encerrar

Embora entender a diferença entre as partições MBR e GPT seja um pouco como descascar uma cebola, espero que você tenha passado por isso sem chorar.

Se tudo o que você deseja é uma referência rápida para as diferenças entre as partições MBR e GPT, aqui está uma tabela útil:

Não se esqueça de não ser como o meu eu mais jovem – certifique-se de ter um backup antes de mexer nas partições. Na verdade, faça dois backups. 🙂

Escrito por: Meet Zaveri

Em Tecnologia da Informação, um boilerplate é uma unidade de escrita que pode ser reutilizada continuamente sem alteração. Por extensão, a ideia às vezes é aplicada à programação reutilizável, como em "código boilerplate".

Contratos legais, incluindo termos e condições de software e hardware, fazem uso abundante de boilerplates.

Por exemplo, um advogado pode dar a você um contrato de cinco páginas para assinar, mas a maior parte do contrato contém um texto padrão (boilerplate) – o que significa que é o mesmo para todos aqueles que recebem esse contrato, com apenas algumas linhas alteradas aqui e ali.

Na programação de computadores, o código boilerplate ou boilerplate refere-se a seções de código que devem ser incluídas em muitos lugares com pouca ou nenhuma alteração. É frequentemente usado quando se refere a linguagens consideradas verborrágicas, ou seja, o programador deve escrever muito código para fazer trabalhos mínimos.

Por exemplo, no desenvolvimento para a web, um boilerplate simples para HTML ficaria assim:

<!DOCTYPE html>
<html class="no-js" lang="">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="x-ua-compatible" content="ie=edge">
        <title></title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial- scale=1, shrink-to-fit=no">
        <link rel="stylesheet" href="css/main.css">
    </head>
    <body>
        <p>Hello world! This is HTML5 Boilerplate.</p>
        <script src="js/vendor/modernizr-{{MODERNIZR_VERSION}}.min.js"></script>
    </body>
</html>

Você pode ver todo o repositório aqui:

h5bp/html5-boilerplate – um modelo de front-end profissional para criar aplicativos web ou sites rápidos, robustos e adaptáveis.

Na década de 1890, o boilerplate era, na verdade, fundido ou estampado em metal pronto para a impressão e distribuído para editoras de jornais e empresas nos Estados Unidos. Até a década de 1950, milhares de jornais recebiam e usavam o boilerplate do maior fornecedor do país, a Western Newspaper Union. Algumas empresas também enviavam comunicados à imprensa como boilerplates, de modo que tinham de ser impressos conforme eram escritos.

A maioria dos desenvolvedores para a web profissionais criou uma coleção de recursos e trechos de código que eles reutilizam em projetos para acelerar o desenvolvimento. Existem alguns padrões universais ou quase universais que todos os sites têm em comum. Em vez de reconstruí-los continuamente, a maioria dos desenvolvedores começa copiando o código usado para um projeto semelhante e, em seguida, começa a modificá-lo.

Alguns desenvolvedores reconhecem o valor desses modelos boilerplate iniciais e reservam um tempo para torná-los mais genéricos e compartilhá-los on-line para que outros possam usá-lo.

Isso não se limita apenas ao desenvolvimento para web. O boilerplate também é usado em AI/ML, pois há mais frameworks e bibliotecas em crescimento.

Características necessárias ao boilerplate para projetos grandes (prontos para produção)

• Documentação de boa qualidade e legível
• Estrutura de código com um nível de abstração mais profundo
• Seguimento do padrão de código adequado
• Ferramenta de CLI (para rápida prototipagem e configuração)
• Escalabilidade
• Ferramentas de teste fáceis
• Módulos de API necessários
• Suporte a internacionalização e localização
• Divisão do código
• Código do servidor e do client para configuração
• Estrutura de navegação e de roteamento adequada

Depois de todas essas especificações mínimas, você deve começar a editar e alterar o código para construir seu projeto.

Existem algumas grandes empresas de tecnologia que até constroem seu próprio boilerplate. Elas o usam para projetos respectivos e similares ao longo do tempo.

Um exemplo perfeito para isso seria o boilerplate do react.js:

react-boilerplate/react-boilerplate – uma base altamente escalável e off-line com a melhor experiência de desenvolvedor…

Boilerplate para projetos menores (scaffolding)

Este tipo de boilerplate é geralmente uma espécie de "conjunto para novatos", ou, de modo profissional, é chamado de “Scaffolding”. Seus principais usuários-alvo são desenvolvedores novatos ou novos adotantes.

Ele se concentra na prototipagem rápida, criando os elementos necessários apenas para novos projetos. Eles exigem menos funcionalidade e não são escaláveis ao longo do tempo e do projeto.

Sua estrutura de código não é muito expandida e não envolve uma camada de abstração mais profunda, pois os usuários precisam apenas criar os recursos principais. Isso elimina a necessidade de utilitários extras.

O exemplo mais simples é o boilerplate do create-react-app, do Facebook:

facebookincubator/create-react-app – crie aplicações React com nenhuma configuração.

Qual é a diferença entre o boilerplate e o modelo (template)?

Como bem diz Joachim Pense (texto em inglês), boilerplate é algo que você copia e cola e apenas adiciona a um documento. Aparece com mais frequência em contratos em que a linguagem é usada e reutilizada, especificando coisas como condições e ressalvas.

Os escritores usam modelos (do inglês, templates) como texto padrão, às vezes com efeitos negativos. Em termos gerais, um modelo é um padrão usado para criar objetos. Na escrita, é uma forma padronizada de algo como um resumo que os escritores podem usar para desenvolver suas próprias versões.

Ao contrário dos boilerplates, os modelos são adaptados para um uso específico. O problema surgiu para mim quando os alunos usaram modelos do Word para seus currículos e todos acabaram parecendo iguais.

Tanto os modelos quanto os boilerplates podem tornar a redação comercial artificial e emperrada se usados de modo imprudente.

Guia de estilo para escrita de código

Independentemente de você estar usando um boilerplate ou não, existem alguns padrões seguidos por empresas para escrever código. Um deles é o guia de estilo. Ele tenta explicar os estilos e padrões básicos usados em várias empresas ou organizações. Geralmente, é regra que os funcionários devam adotar o guia de estilo de escrita de código de sua empresa.

O guia de estilo descreve inúmeras regras para se escrever código, como recuo de tabulações e espaços, nomenclatura de variáveis e funções, escrita de comentários necessários, formatação, estruturas de arquivo de origem, uso do método adequado de estruturas de dados, prevenção de hoisting, escopo, instruções de controle e muito mais.

Os estilos de programação geralmente lidam com a aparência visual do código-fonte com o objetivo de legibilidade. Há muito tempo estão disponíveis softwares que formatam o código-fonte automaticamente, deixando os programadores se concentrarem em nomenclatura, lógica e técnicas superiores.

Como ponto prático, usar um computador para formatar o código-fonte economiza tempo, sendo possível impor padrões em toda a empresa sem debates infinitos e sem resolução. Alguns desses debates incluem: usar tabulações ou espaços para a indentação do código, qual o IDE perfeito para programar e assim por diante. O interessante é que você pode se envolver nesses debates que acontecem, principalmente no Reddit. Você também pode participar de algumas das perguntas e respostas do Stack Overflow.

Para desenvolvedores para a web, o guia de estilo mais comum para JS é o guia de estilo de javascript do Airbnb. É código aberto e todo mundo pode contribuir.

airbnb/javascript – guia de estilo de JavaScript

Se alguém tiver alguma dúvida do porquê o Javascript precisa de um guia de estilo, leia a segunda resposta do relatório de problemas escrito por Harrison Shoff, programador na Airbnb.

Por que o JavaScript precisa de um guia de estilo? · Issue #102 · airbnb/javascript – uma das minhas partes favoritas sobre a comunidade de JavaScript é que as pessoas escolhem escrevê-lo em tantas formas diferentes...

Aqui estão alguns guias de estilo (em inglês) para algumas das linguagens mais populares:

DotNet Code Formatter

Java: Google-Java-Format

Javascript Standard Style (diferente do javascript do airbnb)

PHP Coding Standards Fixer

Python: Google’s YAPF

Ruby: Rubocop

Mais sobre boilerplate: conceito para POO

Em programação orientada a objetos (POO), as classes geralmente são fornecidas com métodos para obter e definir variáveis de instância. As definições desses métodos podem, frequentemente, ser consideradas boilerplates.

Embora o código varie de uma classe para outra, sua estrutura é suficientemente estereotipada para que seja melhor gerado automaticamente do que escrito à mão.

Por exemplo, na classe Java a seguir, que representa um animal de estimação, quase todo o código é boilerplate, exceto pelas declarações de Pet (animal de estimação), name (nome), and owner (proprietário):

public class Pet {
    private String name;
    Person owner;
    Pet(String name, Person owner) {
    	this.name = name;
        this.owner = owner;
    }
    
    public String getName() {
    	return name;
    }
    
    public void setName(String name) {
    	this.name = name;
    }
    
    public Person getOwner() {
    	return owner;
    }
    
    public void setOwner(Person owner) {
    	this.owner = owner;
    }
}

A definição de boilerplate está se tornando mais global em muitas outras linguagens de programação hoje em dia. Vem de linguagens de POO e híbridas – que antes eram processuais, mas se tornaram POO. Elas agora têm o mesmo objetivo de repetir o código que você constrói com um modelo/template/classe/objeto, então adotam esse termo. Você faz um modelo e as únicas coisas que você faz para cada instância de um modelo são os parâmetros individuais.

Esta parte é o que chamamos de boilerplate. Você simplesmente reutiliza o código a partir do qual criou um modelo, mas com parâmetros diferentes.

Boilerplate como API

Já que você está simplesmente reutilizando o código modelo com parâmetros diferentes, isso implica que poderíamos criar APIs reusáveis que só precisam de uma alteração de entradas e saídas.

Conclusão

"Código boilerplate" é qualquer código aparentemente repetitivo que é mostrado várias vezes para obter um resultado que parece ser muito mais simples.

O autor deste artigo o escreveu porque havia sido instruído por um líder de equipe a aprender sobre as muitas variedades de boilerplates que podem ser adequadas ao nosso projeto. Então, ele precisou sair em busca do "boilerplate perfeito".

Todo feedback sobre este artigo é muito bem-vindo! Vamos nessa!

Escrito por: Colin Smith

Há algum tempo, escrevi um artigo sobre a necessidade de um diploma em ciência da computação para se conseguir um emprego em tecnologia. Achei que revisar a minha transcrição seria útil. Com sorte, discutir o que estudei ajudará as pessoas. Quero que todos possam tomar a decisão mais informada possível ao escolher seu caminho para seguir uma carreira em tecnologia.

Isenção de responsabilidade: este artigo foi escrito a partir de minhas lembranças das aulas e da perspectiva de um desenvolvedor para dispositivos móveis. Muitos dos tópicos dessas aulas podem ser especializados e transformados em uma carreira. Portanto, todos eles são importantes para alguém no mundo. Estou escrevendo da minha perspectiva e do ponto de vista de alguém que escolheu a carreira de desenvolvedor mobile.

Programação I, II

Essa foi a essência de tudo o que aprendi e me ajudou a programar. Essas são as aulas onde se aprende a programar. Antes de fazer essas aulas, eu mal tinha programado. Eu tentei obter uma vantagem inicial, mas não fui muito além dos loops.

Essas disciplinas começaram com a criação de um arquivo vazio e fazendo-o compilar em um IDE (usei o Code::Blocks na época). Trabalhamos até criar nosso próprio jogo de batalha baseado em texto. Olhar para o código que escrevi me deixa envergonhado. Percorri um longo caminho desde então. Aqui está o repositório, se você quiser rir (eu só uso um arquivo main.cpp com 1063 linhas de código).

Então, o que eu aprendi aqui? Ousaria dizer que "tudo". Esses cursos foram incrivelmente valiosos e me deram pelo menos 70% do conhecimento necessário para trabalhar profissionalmente como programador. Aprendi instruções if, loops, lógica booleana, criação de classes, criação de estruturas, criação de interfaces, polimorfismo, herança e muito mais. Também usei estruturas básicas de dados, como arrays e vetores.

Estruturas discretas em ciência da computação

Esta disciplina foi adicionada à lista para que as pessoas se acostumem com a lógica booleana, a qual vimos nas duas primeiras semanas de aula. Infelizmente, para nós, alunos desavisados, a disciplina se aprofunda muito, mas muito mais. Aqui estão alguns dos tópicos abordados: "lógica, conjuntos e operações de conjuntos, métodos de prova, definições recursivas, análise combinatória e teoria dos grafos".

Todas essas são coisas são úteis de se saber. A questão é que os alunos são incentivados a fazer essa aula cedo, geralmente junto com Programação I e II. Alguns desses tópicos são bastante avançados. Eu sofreria agora para usar métodos matemáticos de prova. Lembro-me de que realmente tive dificuldades naquela época. Além disso, eu apenas tive que pesquisar no Google o que é análise combinatória. Então, obviamente, não a uso muito.

O fato é que muitas coisas que foi ensinado neste curso não pareciam aplicáveis a uma carreira de ciência da computação na época em que fiz o curso. Agora, sei que a lógica, conjuntos e operações de conjuntos, definições recursivas e a teoria dos grafos podem ser úteis. Esse conhecimento, porém, me veio apenas com a retrospectiva de ser programador há alguns anos.

O que aplico diariamente na minha carreira atual é a lógica e talvez as operações definidas. As definições recursivas e a teoria dos grafos realmente só foram úteis para entrevistas. Cuidado, no entanto, em seguir isso à risca, porque sou um desenvolvedor para dispositivos móveis. Um desenvolvedor de back-end provavelmente achará a teoria dos grafos muito útil.

Estruturas de dados

Esta disciplina foi boa, muito boa. As estruturas de dados são usadas em toda a programação de computadores e são a espinha dorsal da maior parte do código que as pessoas escrevem. Elas nos permitem armazenar dados de um modo útil para os programas que escrevemos. A capacidade de olhar para os dados e saber a melhor maneira de armazená-los para terem um bom desempenho em termos de tempo e espaço é uma habilidade muito útil de se ter.

Aprendi sobre arrays, pilhas, listas vinculadas, listas duplamente vinculadas, árvores, gráficos, heaps e todos os diferentes tipos de estruturas de dados (como árvores de autobalanceamento). Essa disciplina não apenas me ajudou a entender as estruturas de dados, mas também a organizar melhor os dados que eu estava armazenando.

A disciplina foi feita em C, o que a tornou ainda mais interessante. C pode ser muito meticuloso, mas também muito poderoso, se usado corretamente. Tive que ter muito cuidado com o modo como alocava e limpava a memória, o que também foi muito bom para ensinar sobre gerenciamento de memória.

Havia tantas coisas úteis nessas aulas que é difícil tratar de todas elas. Eu nem mencionei o fato de que este é um componente de conhecimento chave para entrevistas em tecnologia. Se você está inseguro em estruturas de dados, comece a revisar alguns princípios básicos, porque eles são muito importantes.

Análise de algoritmos

Esta disciplina foi um pouco útil. Algoritmos são úteis. Eles conduzem os melhores softwares do mundo e os tornam poderosos o suficiente para permanecerem relevantes no mundo moderno. Esta disciplina, porém, teve alguns problemas.

A parte mais útil dela foi aprender a notação Big O. A notação Big O permite que você avalie o código e entenda como ele funcionaria no tempo e no espaço. Em geral, se você estiver medindo o desempenho do código em uma empresa, usará um cronômetro para rastrear o tempo entre as interações. Isso permite que você veja o desempenho do seu software. Isso requer que você escreva o código e avalie os resultados posteriormente.

A notação Big O permite que você faça avaliações do desempenho do código apenas observando o código. Não quero entrar muito nisso, mas se você não conhece a notação Big O, leia esta postagem de blog (em inglês).

Os algoritmos reais que examinamos não eram tão úteis. Tudo o que me lembro é o problema da mochila e o problema do caixeiro-viajante. Eu também tive que escrever código para eles em grupos, o que não foi tão interessante porque havia uma pessoa no meu grupo que foi além do que foi planejado. Isso significa que acabei escrevendo menos código para a implementação final do que gostaria.

Uma compreensão básica de quais algoritmos famosos existem, sua finalidade e como são implementados pode ser útil (principalmente para entrevistas). A notação Big O é a chave aqui. É muito útil no trabalho e também é incrivelmente útil para entrevistas.

Desenvolvimento para a web

Esta disciplina era a que tinha mais habilidades que eram diretamente aplicáveis a um trabalho em tecnologia. Aprendi sobre HTML, CSS, JQuery, JavaScript, PHP e JSON. Aprendi como uma solicitação é enviada do front-end de um site para o back-end, como ela é processada no back-end e enviada de volta ao front-end com uma resposta. Aprendi como criar a UI (interface do usuário) e como interagir com uma camada de dados que, por sua vez, interage com a rede.

No final da disciplina, construí meu próprio site e tomei a iniciativa de aprender Angular. Usei o Angular para deixar meu site chamativo, o que acabou me rendendo meu primeiro estágio. Também adquiri um bom entendimento de como um site funciona internamente.

Esse conhecimento por si só foi ótimo, mas também aprendi como aprender uma linguagem, estrutura ou formato de dados desconhecido e trabalhar com eles na hora. Pesquisei muito no Google esses tópicos para ver exemplos concretos. Aprendi a usar a documentação e a investigação on-line para entender melhor um conceito que precisava aplicar diretamente em um curto espaço de tempo. Esta é uma habilidade chave para quem quer ser um programador experiente.

Introdução a bancos de dados

Eu aprendi principalmente SQL nesta disciplina. Tenho certeza de que examinamos alguns outros conceitos, como sharding e clustering, mas não me lembro deles. Às vezes, uso SQL em meu trabalho atual para executar consultas de dados para eventos que registrei. O SQL será parte integrante do seu trabalho ou você mal o usará. Se precisar, aprenda sobre ele e se torne um especialista. Se não o fizer, não se preocupe muito com isso.

Engenharia de software I, II

Outra disciplina da qual não consigo me lembrar. Acredito que examinamos vários conceitos amplos nesta aula. Cobrimos os métodos de gerenciamento de projetos Scrum e Waterfall. Examinamos testes e todos os diferentes tipos de testes que existem. Cobrimos alguns conceitos de usabilidade e acessibilidade. Na verdade, era apenas um apanhado de conceitos que não se encaixavam em suas próprias classes.

Devido à natureza de colcha de retalhos da disciplina, eu realmente não internalizei nenhum dos conceitos muito bem. Foi bom ter uma visão geral básica dos conceitos abordados, mas gostaria que mais tempo fosse gasto em tópicos individuais importantes, como testes.

Arquitetura de computadores e a linguagem Assembly

Lembro-me vividamente desta disciplina. Ela aborda como um computador funciona e como as instruções da máquina são enviadas e processadas pelo computador. Também escrevemos algum código em MASM, que é uma linguagem Assembly que interage muito de perto com o código de máquina.

A maioria das linguagens de programação que usei até fazer este curso eram linguagens de alto nível. As linguagens de alto nível tendem a estar mais próximas da linguagem humana do que do código de máquina. O MASM está muito próximo do código de máquina e eu diria que está mais próximo da linguagem de máquina do que da linguagem humana.

A parte mais importante da disciplina é ter uma ideia do que acontece com seu código quando ele é compilado. Compreender as diferentes unidades lógicas em um computador e como seu código é tratado por elas foi muito interessante de se aprender.

Para fins práticos, não acho que esta aula tenha sido muito importante para contribuir para minha carreira em tecnologia. Não usei muito do conhecimento que adquiri na disciplina durante minha carreira até agora.

Sistemas operacionais

Serei honesto, estou tendo muita dificuldade em me lembrar o que aprendi nesta disciplina. A única coisa de que me lembro é criar um programa de mensagens que usava programação de soquetes em C para comunicação. Também aprendi como abrir arquivos e manipular pastas usando scripts.

Quero ser sincero sobre o que me lembro da minha graduação e o fato é que não me lembro muito dessa disciplina. Eu simplesmente não usei muito do conhecimento adquirido com ela em minha carreira atual.

Introdução a redes de computadores

Esta disciplina foi muito útil. Examinou como as redes de computadores funcionavam. Isso incluiu passar por protocolos de rede como HTTP, HTTPS, TCP, IP, FTP, IMAP, POP3, SSH e DNS. Pude aprender para que serve cada um desses protocolos, como são implementados e entendi a razão de terem sido criados.

Os protocolos de rede que mencionei acima são usados para funções críticas no software moderno. Isso inclui tratamento de e-mails (POP3 e IMAP), envio de solicitações de rede entre client e servidor (HTTP, HTTPS) e tratamento de dispositivos com segurança por meio de uma rede (SSH). Isso realmente dá uma compreensão de como a internet funciona e de como os dispositivos em todo o mundo podem interagir uns com os outros.

Não é apenas fascinante. Pode ser muito útil. Usei o que aprendi nesta disciplina para depurar problemas que encontrei quando recebia erros da rede. Consegui identificar os problemas que estava encontrando e ajudar o desenvolvedor de back-end com o qual estava trabalhando a encontrar o bug do lado deles.

Introdução à engenharia de usabilidade

Esta disciplina abordou como criar uma aplicação intuitiva, mas também como tornar uma aplicação ou um site acessível. Acessibilidade refere-se a tornar um software utilizável para qualquer pessoa, incluindo pessoas com deficiência. Isso abrange coisas como uso de texto em fala e design de software que não depende totalmente de elementos de áudio.

Os tópicos abordados foram úteis se você nunca ouviu falar sobre acessibilidade antes. Pelo menos, faz considerar essas coisas ao projetar software. Também me levou a realmente começar a pensar sobre a experiência do usuário e sobre como ela é importante para um bom software. Se ninguém estiver usando a funcionalidade principal da sua aplicação porque é confusa, seu software acabará perdendo todos os seus usuários.

Embora o conhecimento fosse interessante, as implementações específicas de como você criaria um software utilizável e acessível dependem da plataforma. Por exemplo, a Apple tem seu próprio conjunto de diretrizes de interface do usuário (em inglês) que descrevem princípios gerais de design e detalhes específicos de como você deve projetar um software que será executado em qualquer uma das plataformas da Apple.

Por causa das informações específicas necessárias por plataforma, não tenho certeza se essa disciplina foi incrivelmente útil. Foi uma boa introdução, mas acabei tendo que aprender as diretrizes de interface da Apple, que abordaram todos os tópicos vistos na disciplina.

Desenvolvimento de software para dispositivos móveis e para a nuvem

Esta seção será curta. Eu já era um engenheiro de mobile quando fiz este curso. Eu construí uma aplicação móvel de baixa qualidade em algumas horas para terminar minha graduação o mais rápido possível. A essa altura, eu já havia alcançado meu objetivo de conseguir um emprego como engenheiro de software, mas só precisava ter meu diploma de ciência da computação, pois estava quase no final do curso. Meu coração não estava interessado em aprender naquele momento.

Dito isso, não acho que esta disciplina foi bem conduzida. Ela foi preguiçosamente projetada. Eles encorajaram as pessoas a escrever código para uma aplicação de telefone Windows para esta classe. A demanda por esses trabalhos é muito menor do que outros. Acho que só foi incentivado porque o ambiente é mais fácil de configurar e o código pode ser escrito em JavaScript e se assemelha ao desenvolvimento para a web.

Além disso, ficou claro para mim que a pessoa que ministrava a disciplina não conhecia todas as plataformas de aplicações móveis. Fomos obrigados a escrever uma pequena parte do back-end, mas eu realmente não queria. Acabei falsificando uma solicitação da web lendo do disco e retornando uma resposta padrão após alguns segundos. Isso funcionou porque só tive que enviar uma demonstração e o código-fonte. Tenho a sensação de que a pessoa que avaliou apenas olhou para a demonstração.

No geral, a disciplina ensinou tecnologia desatualizada e não utilizada, não foi avaliada adequadamente e realmente não ofereceu muita orientação. Esta não foi uma disciplina muito boa.

Projeto final de criação de software

Falando em tecnologia desatualizada, este projeto exigia que construíssemos uma GUI para acessar um banco de dados usando curses (texto em inglês). Não escolhemos qual seria o nosso projeto principal: ele foi atribuído a nós. Todos tinham que fazer o mesmo projeto. Também foi feito em grupos de 3. Então, realmente cobrimos apenas uma pequena parte do projeto. Esta foi uma aula muito mal-administrada.

A interação com o professor era praticamente inexistente. Eu não tinha interesse no projeto e o que estávamos aprendendo parecia absolutamente inútil. Para criar interesse em um tópico, você precisa permitir que as pessoas tenham algum livre arbítrio quando se trata de escolher o que aprender. Não ter escolha em seu projeto final é simplesmente bobo. Esse projeto é inútil para a maioria das carreiras e não faz sentido fazer com que as pessoas o façam.

A disciplina deveria ter feito com que todos os alunos apresentassem uma proposta com estimativas aproximadas de um cronograma de quando terminariam cada subparte do projeto. Isso causa duas coisas: fazer com que as pessoas comecem a praticar a estimativa de trabalho e permitir que trabalhem naquilo em que estão interessadas. A disciplina teria sido 100 vezes melhor desse modo.

Considerações finais

Eu poderia não ter feito boa parte das disciplinas e ainda ser o engenheiro de software que sou hoje. Acho que perder algumas dessas disciplinas pode deixar uma grande lacuna no seu conhecimento como desenvolvedor. As disciplinas que eu acho que todo engenheiro de software deve ter algum conhecimento a respeito são Estruturas de Dados e Algoritmos.

As outras disciplinas dependem da carreira que você escolher. Se você decidiu entrar no desenvolvimento de software embarcado, deve aprender sobre arquitetura de computadores. Se você decidir se tornar um engenheiro de front-end, deve aprender sobre redes de computadores.

A principal conclusão aqui é que um bom engenheiro está constantemente aprendendo. Se você está perdendo algum conhecimento que sabe que seria útil e aplicável em seu trabalho, faça uma aula para obter esse conhecimento. É assim que você melhora a escrita de um bom código. Aprenda sempre.

Gostou do que leu? Confira outros artigos do mesmo autor (em inglês)

Starting a tech career from nothing.

Choose the best tech career for yourself — Dev Ops, Mobile Engineer, Data Scientist, Project Manager, and Front End.

Tips for your first tech interview.

Should you get a computer science degree?

Swift vs. Objective-C

O Nmap é a ferramenta de varredura mais famosa usada para testes de intrusão. Neste artigo, veremos alguns recursos principais do Nmap, bem como alguns comandos úteis.

O que é o Nmap?

Nmap é a abreviação de Network Mapper (em português, "mapeador de rede"). É uma ferramenta de linha de comando do Linux, de código aberto, que é usada para efetuar a varredura (scan) de endereços IP e portas em uma rede e detectar aplicações instaladas.

O Nmap permite que os administradores de rede descubram quais dispositivos estão em sua rede, descubram portas e serviços abertos e detectem vulnerabilidades.

Gordon Lyon, conhecido pelo pseudônimo de Fyodor, escreveu o Nmap como uma ferramenta para ajudar a mapear toda uma rede facilmente e encontrar suas portas e serviços abertos.

O Nmap se tornou extremamente popular, aparecendo em filmes como The Matrix e na popular série Mr. Robot.

Por que usar o Nmap?

Existem várias razões pelas quais os profissionais de segurança preferem o Nmap a outras ferramentas de varredura.

Primeiro, o Nmap ajuda você a mapear rapidamente uma rede sem comandos ou configurações sofisticadas. Ele também tem suporte a comandos simples (por exemplo, para verificar se um host está ativo) e scripts complexos por meio do mecanismo de script do Nmap.

Outros recursos do Nmap incluem:

• Capacidade de reconhecer rapidamente todos os dispositivos, incluindo servidores, roteadores, switches, dispositivos móveis, etc. em uma única rede ou em várias.
• Ajuda a identificar serviços em execução em um sistema, incluindo servidores Web, servidores DNS e outras aplicações comuns. O Nmap também pode detectar versões de aplicações com precisão razoável para ajudar a detectar vulnerabilidades existentes.
• O Nmap pode encontrar informações sobre o sistema operacional em execução nos dispositivos. Ele pode fornecer informações detalhadas, como versões do sistema operacional, facilitando o planejamento de abordagens adicionais durante o teste de intrusão.
• Durante a auditoria de segurança e a varredura de vulnerabilidade, você pode usar o Nmap para atacar sistemas usando scripts existentes do Nmap Scripting Engine.
• O Nmap possui uma interface gráfica de usuário chamada Zenmap. Ela ajuda você a desenvolver mapeamentos visuais de uma rede para melhor a usabilidade e a geração de relatórios.

Comandos

Vamos conferir alguns comandos do Nmap. Se você não tem o Nmap instalado, você pode obtê-lo aqui (site em inglês).

Varreduras básicas

A varredura da lista de dispositivos ativos em uma rede é a primeira etapa no mapeamento de rede. Existem dois tipos de varreduras que você pode usar para isso:

• Varredura com ping — efetua uma varredura da lista de dispositivos ativos e conectados a uma determinada sub-rede.

> nmap -sp 192.168.1.1/24

• Varredura de um único host — efetua a varredura de um único host para mil portas bem conhecidas. Essas portas são aquelas usadas por serviços populares, como SQL, SNTP, apache e outros.

> nmap scanme.nmap.org

Varredura furtiva

A varredura stealth (em português, "furtiva") é realizada enviando um pacote SYN e analisando a resposta. Se SYN/ACK for recebido, significa que a porta está aberta e você pode abrir uma conexão TCP.

No entanto, uma varredura stealth nunca completa a negociação em 3 vias (em inglês, 3-way handshake), o que torna difícil para o alvo determinar o sistema de varredura.

> nmap -sS scanme.nmap.org

Você pode usar o comando '-sS' para executar uma varredura stealth. Lembre-se de que a varredura stealth é mais lenta e não tão agressiva quanto os outros tipos de varredura. Por isso, você pode ter que esperar um pouco para obter uma resposta.

Varredura de versão

Encontrar versões de aplicações é uma parte crucial no teste de intrusão.

Isso facilita sua vida, pois você pode encontrar uma vulnerabilidade existente no banco de dados Common Vulnerabilities and Exploits (CVE) (em uma tradução literal, "vulnerabilidades e exposições comuns") para uma versão específica do serviço. Você pode usá-lo para atacar uma máquina usando uma ferramenta de exploração como o Metasploit (em inglês).

> nmap -sV scanme.nmap.org

Para fazer uma varredura de versão, use o comando '-sV'. O Nmap fornecerá uma lista de serviços com suas versões. Lembre-se de que as varreduras de versão nem sempre são 100% precisas, mas levam você um passo mais perto de entrar com sucesso em um sistema.

Varredura de SO

Além dos serviços e suas versões, o Nmap pode fornecer informações sobre o sistema operacional (SO) subjacente usando TCP/IP fingerprinting (em inglês). O Nmap também tentará encontrar o tempo de atividade do sistema durante uma varredura do sistema operacional.

> nmap -sV scanme.nmap.org

Você pode usar sinalizadores (flags) adicionais como osscan-limit para limitar a pesquisa a alguns alvos esperados. O Nmap exibirá a porcentagem de confiança para cada palpite do sistema operacional.

Novamente, a detecção do sistema operacional nem sempre é precisa, mas ajuda o teste de intrusão a se aproximar de seu alvo.

Varredura agressiva

O Nmap tem um modo agressivo, que permite detecção de SO, de versão, varredura de script e traceroute. Você pode usar o argumento -A para realizar uma varredura agressiva.

> nmap -A scanme.nmap.org

Varreduras agressivas fornecem uma informação muito melhor do que as varreduras comuns. Porém, uma varredura agressiva também envia muito mais sondas, sendo muito mais provável de ser detectada em auditorias de segurança.

Varredura de vários hosts

O Nmap tem a capacidade de efetuar uma varredura de vários hosts simultaneamente. Esse recurso é muito útil quando você está gerenciando uma vasta infraestrutura de rede.

Você pode efetuar a varredura de diversos hosts por meio de várias abordagens:

• Escrever todos os endereços IP em uma única linha para efetuar a varredura de todos os hosts ao mesmo tempo.

> nmap 192.164.1.1 192.164.0.2 192.164.0.2

• Usar o asterisco (*) para efetuar a varredura de toda a sub-rede de uma só vez.

> nmap 192.164.1.*

• Adicionar vírgulas para separar o final de endereços em vez de digitá-los por completo.

> nmap 192.164.0.1,2,3,4

• Usar um hífen para especificar um intervalo de endereços IP.

> nmap 192.164.0.0–255

Varredura de portas

A varredura de portas é um dos recursos mais fundamentais do Nmap. Você pode procurar portas de várias maneiras.

• Usando o parâmetro -p para efetuar a varredura de uma única porta

> nmap -p 973 192.164.0.1

• Se você especificar o tipo de porta, você pode efetuar a varredura de informações sobre um tipo particular de conexão como, por exemplo, para uma conexão TCP.

> nmap -p T:7777, 973 192.164.0.1

• Um intervalo de portas pode ser alvo de varredura separando-as com um hífen.

> nmap -p 76–973 192.164.0.1

• Você também pode usar o sinalizador --top-ports para especificar as n principais portas para varredura.

> nmap --top-ports 10 scanme.nmap.org

Varredura a partir de um arquivo

Se você deseja efetuar a varredura de uma lista grande de endereços IP, você pode fazer isso importando um arquivo com a lista de endereços IP.

> nmap -iL /ips_entrada.txt

O comando acima vai produzir os resultados de varredura de todos os domínios dados no arquivo "ips_entrada.txt". Além de simplesmente digitalizar os endereços IP, você também pode usar opções e sinalizadores adicionais.

Detalhamento e exportação de resultados de varredura

Um teste de intrusão pode durar dias ou, até mesmo, semanas. Exportar os resultados do Nmap pode ser útil para evitar trabalho redundante e ajudar com a criação de relatórios finais. Vamos dar uma olhada nas formas de exportar os resultados de varredura do Nmap.

Saída detalhada

> nmap -v scanme.nmap.org

A saída detalhada (em inglês, verbose) fornece informações adicionais sobre a varredura que está sendo executada. É útil monitorar passo a passo as ações que o Nmap executa em uma rede, especialmente se você for um estranho efetuando a varredura da rede de um cliente.

Saída normal

As varreduras do Nmap também podem ser exportadas para um arquivo de texto. Isso resultará em uma saída um pouco diferente da saída da linha de comando original, mas vai capturar todos os resultados de varredura essenciais.

> nmap -oN saída.txt scanme.nmap.org

Saída em XML

As varreduras do Nmap também podem ser exportadas para XML. É também o formato de arquivo preferido da maioria das ferramentas de teste de intrusão, tornando-o facilmente analisável ao importar resultados da varredura.

> nmap -oX saída.xml scanme.nmap.org

Vários formatos

Você também pode exportar os resultados de varredura em todos os formatos disponíveis de uma só vez usando o comando -oA.

> nmap -oA saída scanme.nmap.org

O comando acima vai exportar o resultado de varredura para três arquivos — saída.xml, saída.nmap e saída.gnmap.

Ajuda do Nmap

O Nmap tem um comando de ajuda embutido que lista todos os sinalizadores e opções que você pode usar. Ele é geralmente útil, considerando a quantidade de argumentos de linha de comando que o Nmap possui.

> nmap -h

Nmap Scripting Engine

O Nmap Scripting Engine (NSE)  – em uma tradução literal, "mecanismo de scripts do Nmap" – é uma ferramenta incrivelmente poderosa que você pode usar para escrever scripts e automatizar vários recursos de rede.

Você pode encontrar muitos scripts distribuídos pelo Nmap ou escrever seu próprio script com base em seus requisitos. Você pode até modificar scripts existentes usando a linguagem de programação Lua.

O NSE também possui scripts de ataque que são usados para atacar a rede e vários protocolos de rede.

Examinar o mecanismo de script em profundidade estaria fora do escopo deste artigo. Portanto, aqui estão mais informações sobre o NSE (em inglês).

Zenmap

O Zenmap é uma interface gráfica de usuário para o Nmap. É um software livre e de código aberto que ajuda quem está começando a usar o Nmap.

Além de fornecer mapeamentos visuais de rede, o Zenmap também permite que você salve e procure suas varreduras para uso futuro.

O Zenmap é ótimo para iniciantes que desejam testar as capacidades do Nmap sem precisar lidar com uma interface de linha de comando.

Conclusão

O Nmap é claramente o "canivete suíço" da rede, graças a seus vários comandos versáteis.

Ele permite que você efetue uma varredura e descubra rapidamente informações essenciais sobre sua rede, hosts, portas, firewalls e sistemas operacionais.

O Nmap possui várias configurações, sinalizadores e preferências que ajudam os administradores de sistema a analisar uma rede em detalhes.

Se você deseja aprender sobre o Nmap a fundo, aqui está um ótimo recurso para você (em inglês).

Gostou deste artigo? Inscreva-se para receber notícias do autor (em inglês).

O AWS IAM (Identity and Access Management) oferece controle sobre quem pode acessar seus serviços e recursos da AWS com base em algumas permissões predefinidas.

As duas palavras-chave aqui são "quem" e "permissões". "Quem" refere-se a uma identidade específica, que pode ser um usuário, grupo ou role (em português, função ou papel). "Permissões" referem-se às políticas anexadas a uma identidade. Essas permissões permitem ou negam acesso a um recurso.

O IAM é a maneira de a AWS autenticar e autorizar identidades. Autenticação não é, no entanto, o mesmo que autorização. A autenticação está relacionada com o "quem", enquanto a autorização está relacionada com as "permissões".

A diferença entre autenticação e autorização

Autenticação é quando uma identidade prova que é o que/quem diz ser. A autorização, por outro lado, prova que você tem as permissões para acessar um recurso.

Para entender completamente a diferença, considere a seguinte analogia. Você precisa ser autenticado e autorizado para embarcar em um voo. A autenticação é feita com o seu passaporte ou documento de identificação, onde é verificado se a fotografia do seu passaporte corresponde ao seu rosto. Isso prova que você é quem diz ser.

Depois de autenticado, você precisa provar que tem permissão para fazer um voo específico. Isso é feito com seu cartão de embarque.

Tanto a autenticação quanto a autorização precisam ser realizadas antes de embarcar em um voo. Do mesmo modo, ambos precisam ser executados antes que você possa acessar os recursos da AWS.

Você pode ler mais sobre autorização versus autenticação aqui.

Os usuários, grupos e roles do IAM se preocupam com a autenticação, ou seja, provar que você é quem diz ser. Eles são como passaportes que permitem que você passe pela segurança de um aeroporto.

Sem um cartão de embarque, no entanto, você não pode embarcar em um avião. A política do IAM é como um cartão de embarque, pois concede ou nega acesso a recursos específicos.

O que são usuários do IAM?

Esta é qualquer identidade (humana ou um aplicativo) que requer acesso de longo prazo aos recursos da AWS. Essas entidades fazem solicitações ao IAM para serem autenticadas antes que qualquer interação com os recursos da AWS seja permitida.

A autenticação é feita usando uma combinação de nome de usuário/senha para humanos acessando a AWS por meio do console ou por meio de chaves de acesso para uma aplicação ou um humano acessando a AWS por meio da interface de linha de comando.

O que são os grupos do IAM?

Os usuários do IAM podem ser colocados em um grupo do IAM. Os grupos do IAM facilitam a organização de um grande número de usuários do IAM e a aplicação de permissões em um nível de grupo em vez de um nível individual. Isso ocorre porque o último não é dimensionado para um grande número de usuários.

Imagine que você tem uma equipe composta por desenvolvedores, arquitetos, equipe administrativa, engenheiros de DevOps, suporte ao vivo e testadores. Cada uma dessas equipes tem 10 pessoas, em um total de 60 pessoas.

Em vez de definir políticas de permissão para 60 pessoas individualmente, você pode colocar usuários do IAM em seus respectivos grupos e aplicar permissões em um nível de grupo. Isso facilita a organização de permissões e também o dimensionamento à medida que sua equipe cresce.

Não há credenciais de login para grupos do IAM. Além disso, um usuário pode pertencer a vários grupos. Por exemplo, um usuário do IAM que está no grupo de DevOps também pode estar no grupo de suporte ao vivo. Isso mapeia perfeitamente o mundo real, onde um engenheiro de DevOps também pode estar no suporte ao vivo.

O que são roles do IAM?

Roles (ou funções) do IAM são usadas para conceder acesso temporário a várias identidades. Essas identidades podem ser pessoas externas à AWS acessando seus serviços, usuários do IAM ou aplicações.

Essas identidades assumem a role temporariamente e quaisquer políticas de permissão anexadas à role são aplicadas por extensão à identidade que assume essa role.

As roles do IAM são importantes porque a AWS tem limites rígidos para o número de usuários do IAM (atualmente, 5 mil – documentação em inglês).

Políticas de confiança x políticas de permissão

As políticas do IAM anexadas às roles são de dois tipos – política de confiança e política de permissão.

A política de confiança controla qual identidade (por exemplo, usuários do IAM, recursos da AWS, como instâncias de EC2, entidades anônimas) pode assumir essa role. Depois que uma role é assumida por uma identidade, a AWS emite credenciais de segurança temporárias (documentação em inglês).

Você pode pensar na política de confiança como a maneira como a AWS autentica uma role do IAM para garantir que apenas a identidade com permissão para assumir a role possa fazer isso, ou seja, que uma identidade tenha provado ser quem/o que diz ser.

Há, no entanto, um porém. Com políticas de confiança, essa autenticação funciona apenas por um período de tempo. Depois de decorrido esse tempo, a identidade precisa se autenticar novamente e obter novas credenciais de segurança temporárias.

A política de permissões é relativamente simples: ela define as permissões que a role tem. A role, por sua vez, define as permissões que a identidade que assumir essa role terá.

As roles do IAM são um conceito relativamente difícil de entender. Portanto, se você ainda não o entende bem, continue lendo e ele ficará mais claro.

Como as políticas do IAM funcionam

As políticas do IAM são anexadas a identidades (portanto, aos usuários, grupos ou roles). As políticas do IAM também podem ser anexadas a alguns recursos da AWS. Esses tipos de políticas são chamados de políticas baseadas em recursos.

As políticas do IAM são documentos JSON, que consistem em uma ou mais instruções que concedem ou negam acesso aos recursos da AWS.

A política do IAM abaixo mostra como as permissões são concedidas a uma identidade para ler e gravar em um bucket de S3.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "ListObjectsInBucket",
            "Effect": "Allow",
            "Action": ["s3:ListBucket"],
            "Resource": ["arn:aws:s3:::bucket-name"]
        },
        {
            "Sid": "AllObjectActions",
            "Effect": "Allow",
            "Action": "s3:*Object",
            "Resource": ["arn:aws:s3:::bucket-name/*"]
        }
    ]
}

• Sid significa "statement ID" (ou, em português, identificação de declaração), um campo opcional que permite ao leitor identificar rapidamente o que uma declaração faz.
• Effect pode ser allow ou deny (em português, permitir ou negar, respectivamente)
• Action refere-se a qual ação você está tentando efetuar. O formato é serviço:operação.
• Resource refere-se a com qual recurso você está interagindo. Tipicamente, você vai usar o ARN (Amazon Resource Name, documentação em inglês) que identifica, de forma exclusiva, recursos da AWS.

Por padrão, todas as solicitações são negadas implicitamente, a menos que uma política tenha explicitamente uma "permissão", como é o caso do exemplo acima.

Esse princípio de privilégio mínimo garante que uma identidade não possa usar um recurso, a menos que receba explicitamente a permissão para fazê-lo.

Juntando tudo – como o IAM funciona

Considere um restaurante. Ele terá alguns funcionários em tempo integral – como chefs, garçons e faxineiros. Também pode ter alguns chefs de meio período para ajudar durante o pico de demanda à noite e nos fins de semana. Se o restaurante for bom, também terá clientes que podem comer no local e levar para viagem.

Para fazer uma analogia com o AWS IAM, os funcionários em tempo integral são como usuários do IAM. Eles exigem acesso de longo prazo aos recursos do restaurante, conforme mostrado acima. Todos esses usuários pertencerão a grupos diferentes – o grupo de garçons, chef e faxineiros (ou seja, todos os garçons, por exemplo, terão o mesmo cargo de "garçom").

Como os funcionários do restaurante são autenticados? Como sabemos que eles são quem dizem ser? Crachás com uma foto servirão. Eles também podem mostrar seu cargo, que é análogo ao grupo IAM ao qual eles pertencem.

As políticas de permissão que definem quais recursos os funcionários do restaurante podem acessar são aplicadas no nível do grupo, pois todos os garçons, chefs e faxineiros terão as mesmas permissões. Isso pode não ser verdade na realidade, pois o chefe de cozinha, por exemplo, pode ter acesso privilegiado. Para simplificar, porém, vamos supor que seja verdade.

Como o gerente do restaurante controla quem tem acesso a quais recursos? Portas com fechaduras servirão perfeitamente. As chaves funcionam como uma política, pois controlam o acesso a partes do restaurante.

Um conjunto idêntico será dado a todos os garçons, uma vez que os garçons precisarão do mesmo nível de acesso ao depósito de alimentos/bebidas, cozinha e mesas.

A mesma lógica será aplicada ao restante dos colaboradores em tempo integral, onde são entregues as devidas chaves para que possam utilizar os recursos do restaurante conforme as suas necessidades.

Fornecer chaves aos funcionários do restaurante é semelhante a anexar uma política a um usuário ou grupo do IAM. Sem as chaves, os funcionários não podem acessar partes do restaurante.

Do mesmo modo, na AWS, sem políticas que permitem explicitamente uma ação, as solicitações não podem ser feitas aos recursos da AWS. O estado padrão na AWS e em nossa analogia com o restaurante é uma negação implícita ao tentar acessar recursos.

Os funcionários de meio período (como um chef temporário, por exemplo) e os clientes não precisam de acesso de longo prazo aos recursos, mas precisarão de acesso de curto prazo, semelhante às roles do IAM.

Os funcionários de meio período só podem trabalhar durante um breve período – digamos durante a noite no fim de semana. Fora desse horário, eles não têm permissão para usar os recursos do restaurante.

O chef de meio período não precisa ser a mesma pessoa. Pode ser uma pessoa diferente a cada semana, ao contrário dos funcionários em tempo integral que têm identidades específicas.

Um chef de meio período, portanto, assumirá a função (role) de chef e receberá um crachá temporário que manterá durante o turno. Isso é análogo a uma entidade que assume uma role do IAM que tem uma política anexada a ela e obtém credenciais de segurança temporárias que expirarão após algum tempo.

Novamente, a política aqui é o conjunto de chaves que concede permissão para partes do restaurante, enquanto a credencial de segurança temporária é o crachá temporário usado para autenticar o chef.

Do mesmo modo, os clientes são análogos às roles do IAM por dois motivos. Primeiro, eles exigem apenas acesso temporário ao restaurante. Em segundo lugar, e talvez mais importante, um restaurante de sucesso terá dezenas de milhares a centenas de milhares de clientes únicos ao longo de sua vida.

Ter um grande número de entidades não identificadas é um caso de uso perfeito para roles do IAM. Lembre-se de que, com a AWS, há um limite rígido de 5 mil para o número de usuários do IAM que você pode ter. Se houver um caso de uso em que o número necessário de usuários do IAM exceda esse limite de 5 mil, usar as roles do IAM é sua única opção.

Assim como as funções do IAM são assumidas, o cliente primeiro precisa solicitar algo para provar que é um cliente e pode assumir a role de cliente.

Depois que a role do cliente é assumida, a política de permissões anexada à role do cliente também é aplicada ao cliente. Os clientes têm permissão para usar apenas alguns recursos, como as mesas e o banheiro.

Para manter a analogia realista, o acesso ao banheiro é controlado digitando uma senha que muda todos os dias, garantindo assim que o acesso seja temporário. Essa senha é análoga à política anexada à role do cliente que concede acesso temporário ao banheiro.

Exemplo de caso de uso de roles do IAM

Considere a seguinte arquitetura muito simples: uma instância de EC2 executando uma aplicação que precisa de acesso total a um bucket de S3.

Como você daria à instância de EC2 permissão para ler e gravar objetos de um bucket do S3? Isso é explicado no diagrama abaixo:

1. Crie uma role do IAM para sua instância do EC2
2. Anexe uma política do IAM à role que concede acesso total ao bucket de S3
3. Deixe a instância de EC2 assumir a role

A política de IAM para o acesso total ao S3 mencionado na etapa 2 é:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:*",
                "s3-object-lambda:*"
            ],
            "Resource": "*"
        }
    ]
}

Agora, você pode ler e gravar no bucket do S3. Observe que, na política acima, não é especificado nenhum ARN. Ela apenas contém "*" para o recurso. Isso representa todos os buckets de S3. Se é isso que você quer, então essa política serve. Se, porém, você quiser especificar um único bucket, precisará fornecer o ARN do bucket.

Resumo

Compreender o IAM e a diferença entre usuários, roles, grupos e como as políticas funcionam oferece a você uma base sólida sobre a qual você pode arquitetar e criar soluções seguras com a AWS.

Obrigado pela leitura!

Quando você está começando no desenvolvimento para a web, provavelmente, ouvirá os termos autenticação e autorização o tempo todo. Não ajuda o fato de que ambos sejam geralmente abreviados como "auth". Então, é muito fácil confundir os dois.

Neste artigo, você aprenderá:

• As diferenças entre autenticação e autorização
• Como cada um desses processos funciona
• Exemplos de autorização e autenticação na vida cotidiana.

‌‌‌‌Vamos começar.

O que é autenticação?

Autenticação é o processo de verificação das credenciais que um usuário fornece com aquelas armazenadas em um sistema para provar que o usuário é quem diz ser. Se as credenciais corresponderem, você concederá acesso. Se não, você nega.

Métodos de autenticação

Autenticação de fator único:

Isso, geralmente, é usado como processo de autenticação para sistemas de menor risco. Você só precisa de um único fator para autenticar, sendo o mais comum uma senha. Por isso, é mais vulnerável a ataques de phishing e keyloggers.

Além disso, um artigo (em inglês) recente da DataProt mostrou que 78% das pessoas da geração Z utilizam a mesma senha para vários serviços. Isso significa que, se um invasor obtiver acesso a uma conta de usuário, ele terá uma alta probabilidade de obter acesso a outros serviços simplesmente usando a mesma senha.

Autenticação de dois fatores:

Este método é mais seguro, pois compreende dois fatores de autenticação – normalmente, algo que você conhece – por exemplo, nome de usuário e senha, mais algo que você possui, por exemplo, um SMS de telefone ou um token de segurança.

Para a autenticação de dois fatores, você deve inserir uma senha SMS única enviada para o seu dispositivo, ou talvez um código de uma aplicação de autenticação vinculada e fornecer um código de acesso em constante mudança.

Como você pode imaginar, isso é muito mais seguro do que simplesmente inserir uma senha ou uma única credencial de autenticação. Você precisaria saber as credenciais de login, bem como ter acesso ao dispositivo físico para a segunda parte.

A autenticação de dois fatores tornou-se muito comum entre os serviços on-line nos últimos anos e, em muitas grandes empresas, é o método de autenticação padrão. Muitos exigem que você configure a autenticação de dois fatores para utilizar o serviço.

Autenticação multifator:

Dar um passo além para tornar seu processo de autenticação ainda mais seguro é ter 3 ou mais fatores. Esse modo de autenticação geralmente funciona com base em:

• algo que você conhece (nome de usuário + senha ou um nome de usuário + pergunta e resposta de segurança)
• algo que você tem (sms de celular, aplicação de autenticação, chave USB)
• algo que você é (como uma impressão digital / reconhecimento facial)

Por esses motivos, a autenticação multifator oferece mais proteção, pois você precisaria de uma combinação dos vários fatores. Esses fatores são muito mais difíceis de "hackear" ou replicar.

A desvantagem desse método de autenticação e o motivo pelo qual não é utilizado em muitos sistemas comuns é que pode ser complicado de configurar e de manter. Portanto, os dados/sistema que você está protegendo realmente precisam justificar a necessidade de tal segurança.

Então, quanta informação você precisa para autenticar?

Essa pergunta surge em muitas reuniões de arquitetura de segurança e a resposta é: "depende".

Não é incomum que as empresas combinem vários métodos de autenticação para aumentar a segurança com base na natureza da aplicação.

Por exemplo, pegue uma aplicação bancária. Ela contém informações muito confidenciais e pode ter um grande impacto financeiro e de reputação se for obtido pela pessoa errada. O banco pode combinar perguntas pessoais a serem respondidas, juntamente com um número do cliente e uma senha complexa.

Por outro lado, para um site de mídia social, você pode exigir apenas um nome de usuário e senha, que são verificados antes de permitir o acesso.

Tudo está relacionado ao nível de risco envolvido e a quais informações alguém pode acessar quando estiver na aplicação. Isso ajuda a determinar o nível de autenticação necessário.

Se você ou sua equipe subestimar o nível de autenticação que sua aplicação precisa, poderá ser processado por não proteger os dados em seu sistema adequadamente. Por isso, as empresas empregam especialistas em segurança para aconselhar sobre as melhores práticas e soluções adequadas.

Como funciona a autenticação no mundo real?

Vamos dar um exemplo de uma conta de mídia social. Você escolhe seu site de mídia social favorito (hospedado em um servidor). O servidor solicitará que você forneça credenciais para acessar o site por meio de uma página de login. Aqui, você digitaria seu nome de usuário e senha que você usou ao criar a conta.

Esses detalhes são enviados ao servidor e o processo de autenticação é iniciado. Os detalhes que você forneceu são verificados e conferidos no banco de dados do servidor e, se corresponderem aos detalhes registrados, você será autenticado. Em seguida, você recebe uma espécie de dados de identificação, por exemplo, um cookie ou Json Web Token (token JWT).

Sucesso! Você acessou o site e recebeu direito de entrada.

Você pode aprender mais sobre os tokens JWT em outro artigo do FreeCodeCamp, de Beau Carnes, aqui (texto em inglês).

Em seguida, vamos ver a autorização.

O que é autorização?

Autorização é o processo de verificar se você tem permissão para acessar uma área de uma aplicação ou executar ações específicas, com base em determinados critérios e condições estabelecidos pela aplicação. Você também pode ouvi-lo ser chamado de controle de acesso ou controle de privilégio.

A autorização pode conceder ou negar permissão para realizar tarefas ou acessar áreas de uma aplicação.

Vejamos um exemplo:

Obtivemos acesso ao site de mídia social, mas o que podemos fazer lá depende do que estamos autorizados a fazer.

Se tentarmos acessar o perfil de alguém de quem não somos amigos (eles não aceitaram nosso pedido de conexão), não estamos autorizados a visualizar seu perfil. Isso significa que não temos permissão para visualizar suas postagens compartilhadas.

Como implementar autorização

Há muitas maneiras de implementar a autorização, dependendo dos frameworks que você está usando.

Dentro do .NET Framework, por exemplo, você pode usar controle de acesso baseado em função ou controle de acesso baseado em reivindicações.

O controle de acesso baseado em função é centrado na ideologia de que cada usuário em seu sistema recebe uma função. Essas funções têm permissões predefinidas associadas a elas. Receber uma função significa que o usuário herdará automaticamente todas essas permissões. As funções são atribuídas no momento da criação e configuração do usuário.

O endpoint ou site simplesmente verifica se o usuário conectado no momento tem a função de administrador ao tentar acessar a área de administração.

A desvantagem dessa abordagem é que, às vezes, os usuários recebem muitas permissões que não precisam ou não deveriam ter.

Por exemplo, atribuir a um usuário a função de Admin pode significar que ele teria privilégios de Advanced Create, Edit, Delete e View. Considerando que, você pode querer dar a ele apenas as permissões View e Basic Create.

O controle de acesso baseado em reivindicações pode permitir um ajuste mais fino das permissões de um usuário específico. A aplicação pode verificar se a reivindicação simplesmente existe em um usuário ou se um valor específico é atribuído à reivindicação.

Por exemplo, uma reivindicação chamada CreateUser pode ser fornecida a um usuário e isso é verificado ao criar um usuário. Ou você pode atribuir um valor de Advanced à mesma reivindicação e, em seguida, ter diferentes ações e interfaces de usuário disponíveis, dependendo se o valor for Advanced ou Basic.

Qual é a diferença entre autenticação e autorização?

Portanto, agora que entendemos melhor os termos, vamos ver um cenário com o qual você pode estar familiarizado e que envolve os dois processos.

Em um jantar com lista exclusiva de convidados, cada convidado recebe um apelido e uma senha secreta.

Na chegada, um guarda de segurança pede seu apelido e senha secreta. Ele, então, autentica suas credenciais na lista que possui. Se suas credenciais corresponderem, você receberá um envelope mostrando que foi autorizado a entrar.

Uma vez lá dentro, você tem permissão para acessar a festa e as áreas públicas do local, pois não precisam de autorização (todos têm permissão para aproveitar a festa). No entanto, você deseja visitar a área VIP.

Conforme você se aproxima, outro segurança pede para abrir seu envelope (suas permissões e funções). Ele dá uma olhada, mas, infelizmente, você não tem a função VIP e, portanto, não está autorizado a acessar. Simplificando, a autenticação verifica a identidade de um usuário ou serviço que permite o acesso, enquanto a autorização determina o que eles podem fazer depois de entrar.

Por que você deve implementar autenticação e autorização?

Como você pode ver, embora autenticação e autorização sejam muito diferentes, cada uma desempenha um papel integral na segurança e integridade da aplicação ou sistema.

Esses processos andam de mãos dadas e, sem um, o outro não tem sentido. Se você pode obter acesso à área de administração, mas fazer o que quiser uma vez lá, isso pode levar a grandes problemas.

Por outro lado, você não pode autorizar pessoas sem saber quem são! É por isso que a autenticação sempre vem antes da autorização.

Considerações finais

Espero que este artigo tenha sido esclarecedor e agora você tenha uma compreensão mais clara das diferenças entre autorização e autenticação e como usá-las.

Lembre-se:

• Autenticação =  verificar a identidade de um usuário ou processo
• Autorização = determinar se o usuário/sistema tem permissão para usar um recurso ou realizar uma ação

Sinta-se à vontade para entrar em contato via Twitter se desejar discutir este artigo com o autor em mais detalhes: @gweaths.

Nunca houve um ano melhor para aprender React, a biblioteca mais popular do JavaScript para criar aplicações front-end, do que neste ano.

Neste guia, mostrarei os recursos e dicas mais valiosos que, acredito, ajudarão você a aprender React mais rapidamente. Você também economizará muito tempo e energia preciosos no processo.

Precisa aprender JavaScript? Você pode aprender enquanto aprende React

A pergunta que os iniciantes que procuram aprender mais fazem React é: "preciso aprender JavaScript?"

O React é uma biblioteca do JavaScript e geralmente é anunciado como sendo "apenas JavaScript". Isso sugere que, para realmente aprender React, você deve conhecer JavaScript primeiro. A maneira como eu caracterizaria o relacionamento do JavaScript com o React é – quanto melhor você conhecer o JavaScript, melhor desenvolvedor do React você se tornará.

Dito isso, você não precisa aprender tudo sobre JavaScript primeiro. Muitos conceitos de JavaScript podem ser aprendidos ao mesmo tempo em que você aprende React.

Aqui está uma lista de alguns dos conceitos em JavaScript que você precisará entender para poder usar o React de modo eficaz. Eles incluem:

• Variáveis
• Arrays (e a função .map())
• Objetos
• Eventos em JavaScript
• Funções e arrow functions
• Escopos e closures
• Promises e sintaxe de async-await
• Tratamento de erros básico

Esses são todos os conceitos de JavaScript que, na minha experiência, você realmente precisa saber para trabalhar com o React em qualquer nível.

Você encontrará e aprenderá mais conceitos do React ao começar a construir seus próprios projetos e observar o código de outros.

Se você deseja um guia útil para começar a aprender esses conceitos e muito mais hoje, o autor deste artigo criou uma extensa ficha informativa no freeCodeCamp (em inglês), que abrange todo o JavaScript de que você precisa para se sentir confiante com o React.

Procurando por um tutorial? Use a nova documentação do React

Quando você inicia seu caminho de aprendizado do React, sua primeira pergunta provavelmente será: "onde aprendo todas as informações relacionadas ao React de que preciso?" Você pode estar se perguntando se deve assistir a cursos no YouTube ou comprar um curso na Udemy.

Embora existam excelentes (e extensos) cursos de React em muitos sites diferentes, o primeiro e principal site em que você deve confiar é o site oficial de documentação do React: reactjs.org.

O que há de muito especial em aprender React neste ano em contraste com os anos anteriores é que, no ano passado, a documentação do React foi completamente atualizada e aprimorada. Ela está totalmente atualizada com a versão atual do React, tem muitos exemplos práticos e até sandboxes de código interativos para que você possa começar a aprender React no navegador sem precisar criar projetos em sua própria máquina.

Se você quiser criar um novo projeto do React, poderá fazê-lo rapidamente no navegador usando o link react.new. Ele criará um CodeSandbox com uma aplicação do React completa para você utilizar. É muito mais rápido e fácil fazer isso do que criar um projeto no seu próprio computador.

Você pode encontrar a nova documentação do React em beta.reactjs.org. No devido tempo, você poderá encontrá-la simplesmente em reactjs.org.

Outro grande motivo para usar a nova documentação do React é que ela é muito amigável para iniciantes e, na minha opinião, permitirá que você aprenda conceitos muito mais rápido do que faria de outro modo. Se você se sentiu intimidado ao ler a documentação técnica no passado, acho que ficará agradavelmente surpreso.

Você não precisa aprender componentes de classe

Se você está se perguntando se precisa aprender os componentes da classe neste ano, não. Não precisa.

Conforme você começa a aprender React, você ouvirá sobre algo chamado componente de classe, que é baseado em uma classe do JavaScript normal. Não é mais necessário aprender isso para ser um desenvolvedor do React, mas ainda pode ser útil aprender.

Após a introdução de um recurso chamado React hooks, em 2018, os desenvolvedores do React passaram a usar componentes de função, que são feitos com funções do JavaScript.

Os componentes de classe ainda fazem parte do React e ainda são usados no código de produção em várias situações (como em limites de erro). Esteja ciente, porém, de que você não precisa aprendê-los para ser habilidoso no React.

Na verdade, eu raramente os encontrei, a menos que esteja olhando para uma base de código mais antiga. A maioria das classes já foi migrada para componentes de função e hooks do React.

Faça um favor a você mesmo e aprenda React Query

Qualquer aplicação séria precisa de dados. Muitas vezes, os dados de que você precisa existirão fora de sua aplicação, portanto, você precisará de uma estratégia para buscá-los e usá-los em seu projeto.

Quando você chegar ao ponto de buscar dados, eu recomendo fortemente que você aprenda uma biblioteca chamada React Query.

Você pode instalar o React Query através do pacote npm @tanstack/react-query.

O React Query se tornou a biblioteca ideal para buscar e gerenciar dados externos em aplicações do React.

Qual é o benefício de se usar o React Query? Além de ser uma biblioteca com a qual muitos desenvolvedores e empresas do React estão familiarizados e confiam, será muito benéfico para você aprender o React Query porque é, sem dúvida, a maneira mais poderosa de buscar e gerenciar dados externos em suas aplicações do React.

O maior benefício de usar o React Query vem do fato de que ele fornece um cache (um armazenamento) que permite manter o resultado de cada consulta, para que você possa "salvar" os dados que você buscou. Além disso, possui muitas ferramentas para atualizar esse cache exatamente da maneira que você deseja.

Ele também apresenta informações relevantes sobre o status de cada consulta que você faz, como, por exemplo, quando ela está carregando ou quando resultou em um erro.

Eu aprenderia o React Query depois que você se sentir confortável em buscar dados manualmente usando ferramentas como Fetch API, Axios com o hook useEffect. Assim que estiver, você verá o benefício de usar o React Query em todos os seus projetos do React.

Você não precisa aprender Redux

Se você tentou aprender React anos atrás, pode ter ficado com a impressão de que, para aprender React, você finalmente teve que aprender outra biblioteca chamada Redux.

O Redux é uma biblioteca que nos ajuda a gerenciar o estado (do inglês, state) em nossas aplicações do React. Você pode pensar em estado como quaisquer dados que podem mudar em uma aplicação do React. O Redux nos permite gerenciar uma parte do estado (como, por exemplo, se o nosso usuário está logado) em todas as partes de nossa aplicação do React.

Não é mais necessário aprender o Redux como era nos anos anteriores. A primeira razão para isso é o lançamento da API React Context. Em muitos casos, os desenvolvedores do React usaram o Redux apenas para passar dados pelos componentes de suas aplicações. Este é um trabalho que o React Context pode fazer por nós.

Além disso, se você precisar alterar ou atualizar o estado em muitas partes diferentes de sua aplicação (o que é um requisito diferente da simples leitura do seu estado), existem muitos concorrentes para o Redux. Ao contrário do Redux, essas bibliotecas não exigem que você aprenda novos conceitos, como redutores, ações e assim por diante.

Algumas dessas bibliotecas de gerenciamento de estado mais recentes e "mais leves" incluem:

• Zustand
• Jotai
• Recoil

Uma vez que você supere o básico do React e comece a construir aplicações um pouco maiores além da aplicação de tarefas padrão, você entenderá a necessidade de ter uma biblioteca de gerenciamento de estado. O Redux ainda é uma ótima biblioteca, mas primeiro procure uma biblioteca com uma API mais simples, como o Zustand.

O Create React App não é necessário

Assim que estiver no ponto de criar um projeto do React por conta própria que resida em seu computador, saiba que há muitas maneiras de fazer isso.

O desenvolvimento para a web em geral está cada vez mais on-line – nem todo projeto do React precisa ser feito no seu computador. Em muitos casos, você pode criar um projeto no navegador usando ferramentas como CodeSandbox ou StackBlitz totalmente grátis.

Haverá um ponto, no entanto, em que você precisará ou desejará criar um projeto do React em sua máquina local. É fácil buscar uma ferramenta como o Create React App, que permite criar um projeto do React executando um único comando.

O Create React App ainda é uma ótima ferramenta para se fazer projetos em React. Assim como no Redux, surgiram novas alternativas que oferecem todas as conveniências do Create React App, mas em um pacote menor e geralmente mais rápido.

O principal exemplo disso é o Vite. O Vite é uma ferramenta de construção que permite criar um projeto do React, bem como muitos outros tipos de projetos em JavaScript.

O benefício de se usar o Vite em vez do Create React App está no fato de ele oferecer um servidor de desenvolvimento muito mais rápido.

Para desenvolver e fazer alterações em sua aplicação, ele deve ser executado em um servidor de desenvolvimento. O Create React App, em comparação, pode levar um tempo relativamente longo para iniciar e responder às alterações no código que você faz (isso é chamado de hot reloading, em inglês). O Vite fornece uma experiência muito mais rápida, além de exigir muito menos dependências.

Outra ótima alternativa ao Create React App é o Next.js. O Next é, tecnicamente, um framework do React que vem com muitas conveniências para tornar o desenvolvimento muito mais fácil. Ele vem com seu próprio roteador e ferramentas de busca de dados, para citar algumas dessas conveniências.

O benefício de se usar um framework como Next.js é que você simplesmente precisa tomar menos decisões quando se trata de construir seu projeto. Você precisa escolher muito menos dependências das quais seu projeto depende. Quase tudo o que você precisa para criar sua aplicação do React vem embutido no Next.js.

Dito isso, o Next opera de maneira bastante diferente dos projetos normais do React devido ao fato de ser renderizado pelo servidor por padrão. Isso pode vir com seus próprios problemas e possíveis armadilhas a serem evitadas. Se você, contudo, estiver interessado em criar projetos do React sérios e prontos para produção, o Next é indiscutivelmente a melhor escolha.

Neste artigo, abordarei algumas das perguntas mais comuns que surgem em entrevistas sobre o AWS Lambda.

Observe que esta não é uma lista exaustiva – você pode usar este guia, no entanto, como uma referência para atualizar seu conhecimento e obter indicações de estudos mais aprofundados.

A maioria das perguntas será baseada em sua experiência ou em determinados cenários. As perguntas estão nos títulos e você encontrará, logo abaixo delas, observações sobre o raciocínio por trás de fazer as perguntas.

Explique seu último projeto envolvendo o AWS Lambda

O entrevistador quer saber sobre sua experiência na vida real usando o AWS Lambda. Não blefe aqui, pois o entrevistador pode fazer mais perguntas com base nas respostas a essa pergunta.

Você pode ter criado uma API sem servidor (em inglês, serverless), sistemas envolvendo microsserviços, conversão de imagem/vídeo, análise de logs e muito mais. Apenas explique seu projeto em detalhes e fale sobre os benefícios comerciais desse projeto para que o entrevistador saiba que você está vendo o quadro geral.

Quais serviços você integrou com o AWS Lambda?

Essa é uma extensão da pergunta anterior. Ela não é uma lista completa de todas as fontes de eventos que podem se conectar ao AWS Lambda. Conte apenas sobre os serviços que você realmente usou.

Você pode ter usado S3, SNS, SQS, Kinesis, DynamoDB, SES ou outros. Nem todos os projetos serão completamente sem servidor.

Se você usou algum componente sem servidor junto com o AWS Lambda, mencione-os também. Por exemplo, você pode ter usado AWS Lambda com RDS. Se você usou essa configuração, pode explicar sobre isso em seu raciocínio.

Explique o conceito de inicializações a quente e a frio (warm and cold starts) no AWS Lambda

Há duas razões para fazer esta pergunta. Eles querem saber os tempos de execução que você usou e querem saber se você conhece os outros tempos de execução que podem causar uma inicialização a frio.

Os serviços Lambda recebem uma solicitação para executar uma função lambda. O serviço prepara o ambiente de execução baixando o código da função do manipulador e alocando memória junto com outra configuração.

Mesmo que você não seja cobrado por esse tempo de preparação do ambiente de execução, terá que enfrentar o atraso na chamada de sua função lambda. Esse atraso é chamado de "inicialização a frio" (do inglês, "cold start").

O tempo de inicialização a frio é menos significativo para ambientes de tempo de execução do TypeScript e do Python, sendo um pouco maior para ambientes de tempo de execução do Java ou do C#.

Para melhorar o desempenho, o serviço lambda manterá o ambiente de execução por algum tempo. Quando você receber a solicitação para a mesma função lambda novamente durante esse período, seu manipulador poderá começar a executar imediatamente. Esse tipo de chamada é chamada de "inicialização a quente" (do inglês, "warm start").

Qual é a diferença entre invocação síncrona e assíncrona no AWS Lambda?

Mesmo que pareça uma pergunta direta, ela tem muitas implicações para o seu design e tratamento de erros.

Na invocação síncrona, o chamador aguardará a conclusão da execução. Na invocação assíncrona, contudo, o chamador colocará o evento em uma fila interna que, posteriormente, será processada na função lambda.

Um ponto importante a ser observado aqui é que você não pode ditar o tipo de invocação. Isso depende do serviço que você usa com o AWS Lambda.

Por exemplo, se você estiver criando APIs sem servidor usando o API Gateway, será uma invocação síncrona. Se você, no entanto, estiver usando o S3, será uma invocação assíncrona.

Como você implementa tratamento de erros e lógica de novas tentativas no Lambda?

Qualquer componente no sistema orientado a eventos que possa falhar, falhará. Então, o entrevistador quer saber como você lidou com o erro e como tentou novamente em seus projetos anteriores. Abaixo estão alguns exemplos. Sempre explique com exemplos concretos.

Isso depende do serviço que você está usando com o AWS Lambda. Vamos discutir alguns exemplos.

Se você estiver criando uma API sem servidor, é melhor retornar esse erro para o client de chamada (pode ser uma aplicação de front-end neste caso). Em seguida, você permite que sua lógica de front-end decida o que exibir ao usuário com base no tipo de erro.

Se você estiver usando o Lambda com SQS, é melhor usar uma Dead Letter Queue para saber quais mensagens não foram processadas. Por esse mesmo motivo, muitos dos sistemas que usam SNS também podem usar SQS.

No código abaixo, estamos usando uma dead letter queue. Se alguma mensagem não for processada após um determinado número de vezes (conforme especificado por maxReceiveCount), ela será enviada para a "fila de mensagens mortas". Esse comportamento é específico para lambda quando usado junto com filas.

const queue = new sqs.Queue(this, 'AwsLambdaSqsQueue', {
      visibilityTimeout: cdk.Duration.seconds(300),
      receiveMessageWaitTime: cdk.Duration.seconds(20),
      deadLetterQueue: {
        queue: new sqs.Queue(this, 'AwsLambdaDlq'),
        maxReceiveCount: 5,
      },
    });

Quando o lambda é invocado com qualquer outro serviço, você pode configurar o número de tentativas com um valor máximo de 2. Isso significa que você pode ter, no máximo, duas tentativas além da chamada inicial. Por exemplo, você deseja acionar com base no upload do objeto S3 e seu lambda tentará no máximo três vezes.

Explique seus fluxos de trabalho para desenvolvimento e implantação de funções do AWS Lambda

Fale sobre os frameworks que você usou. O entrevistador pode esperar que você fale sobre o teste de funções lambda também.

Você pode explicar quais frameworks você usou para desenvolver e implantar funções lambda. Você também pode falar sobre qualquer ferramenta de IaC (Infraestrutura como Código) que você usou.

Abaixo, temos uma lista não exaustiva dos frameworks mais usados:

• Serverless
• AWS CDK
• AWS SAM
• CloudFormation
• Pulumi

Se você já usou o Terraform, também pode falar sobre isso.

O Lambda pode ser invocado quando você recebe um e-mail para um determinado endereço de e-mail de suporte? Se sim, projete esse sistema. Se não, explique por quê.

Sim, você pode. Você pode criar um conjunto de regras de recebimento e adicionar uma regra que acione a função lambda.

Você deve armazenar o e-mail no S3 e acionar o lambda depois disso para que possa ter a cópia do e-mail para qualquer referência futura.

Você pode consultar este artigo (em inglês) sobre como receber e-mails de um formulário de contato.

Uma função lambda pode chamar outra função lambda?

O entrevistador quer saber se você conhece esse antipadrão.

Você pode fazer isso, mas não é recomendado. Se quiser criar um fluxo de trabalho que envolva várias funções lambda, você pode usar as funções de etapa.

Você pode ler mais sobre funções de etapa aqui.

Outra abordagem padrão é emitir um evento e acionar um lambda com base no evento. Você pode usar SQS, SNS ou EventBridge como intermediário para esses eventos.

Você pode executar consultas em uma instância do RDS (em uma sub-rede privada) usando o Lambda?

Sim, você pode executar a consulta no RDS usando o AWS Lambda. Para isso, você pode ter seu lambda dentro da mesma VPC.

Pode haver algumas implicações de desempenho se você usar o AWS Lambda diretamente com o RDS. Isso ocorre devido ao tempo de criação da conexão do banco de dados. Para evitar essas implicações, você pode usar um RDS Proxy.

Aqui está um guia passo a passo detalhado (em inglês) que mostra como fazer isso.

O AWS Lambda fornece muitos benefícios. Quais são as desvantagens de se usar o AWS Lambda?

O entrevistador quer saber sobre o seu processo de pensamento. Não diga que o AWS Lambda resolve todos os problemas. 🙂

Sim, o Lambda oferece muitos benefícios, como custo e escalabilidade, sem a necessidade de manter os servidores. Ele, porém, não é a resposta para tudo. Como qualquer serviço, ele tem seus próprios problemas (e você deve ser capaz de discuti-los):

• Depuração: se você estiver usando arquiteturas sem servidor usando o Lambda, talvez precise contar com o log para encontrar a causa raiz do problema. Isso ocorre porque seu aplicativo será distribuído em muitos serviços/funções lambda.
• Teste: você pode simular serviços da AWS em seu teste local. É melhor, no entanto, ter um ambiente separado na AWS para testar seus lambdas. Isso torna o teste um pouco complexo.
• Tarefas em segundo plano: o Lambda tem um limite de tempo limite de 15 minutos. Se você deseja que qualquer tarefa específica leve mais de 15 minutos, talvez seja necessário mudar para o Fargate ou alguma outra solução.
• Custo: se você estiver executando um aplicativo de alto tráfego que processa as solicitações 24 horas por dia, 7 dias por semana, o uso de lambda pode ser caro. É melhor usar Fargate, EC2 ou outros serviços, se você tiver alto tráfego constante.

Como você gerencia simultaneidade e dimensionamento no AWS Lambda?

Você ganhará pontos de bônus se falar sobre os problemas que enfrentou nessas situações.

Simultaneidade (em inglês, concurrency) é a capacidade de executar várias funções lambda ao mesmo tempo. O dimensionamento (scaling) é o processo de aumentar o número de cópias de sua função lambda para lidar com as solicitações recebidas.

Você pode controlar a simultaneidade definindo o valor de simultaneidade reservada para que apenas o número mencionado de funções lambda seja invocado.

Abaixo está o diagrama de alto nível de como lambda escala de acordo com o número de mensagens na fila.

Observação: há algum comportamento estranho se você tentar limitar o AWS Lambda quando usado com a fila padrão do SQS. Você pode usar uma fila FIFO para resolver esse problema.

Como você passa variáveis de ambiente para o AWS Lambda?

O entrevistador pode querer saber como você passa informações sigilosas, por exemplo.

Existem diferentes maneiras de passar variáveis de ambiente para o AWS Lambda, dependendo do tipo de valor que está sendo passado.

Dados não confidenciais: se você deseja passar informações não confidenciais, pode passar os valores diretamente para as variáveis de ambiente da função lambda. Esses valores, contudo, seriam visíveis no console da AWS no serviço Lambda. No exemplo de código abaixo, estamos passando o nome da tabela DynamoDB diretamente como variável de ambiente, pois não são dados confidenciais:

   const readDDBLambdaFn = new NodejsFunction(this, 'readDDBLambdaFn', {
      entry: path.join(__dirname, '../src/lambdas', 'read-ddb.ts'),
      ...nodeJsFunctionProps,
      functionName: 'readDDBLambdaFn',
      environment: {
        tableName: table.tableName,
      },
    });

Dados confidenciais: se você deseja transmitir dados confidenciais, como senhas e chaves de API, pode usar um gerenciador de segredos ou um armazenamento de parâmetros. Porém, você precisa se certificar de fornecer as funções necessárias ao Lambda para acessar e descriptografar segredos dos respectivos serviços.

No trecho de código abaixo, NÃO estamos passando o segredo real. Em vez disso, estamos apenas passando o ARN (Amazon Resource Name) do segredo.

const rdsLambdaFn = new NodejsFunction(this, 'rdsLambdaFn', {
      entry: path.join(__dirname, '../src/lambdas', 'rds-lambda.ts'),
      ...nodeJsFunctionProps,
      functionName: 'rdsLambdaFn',
      environment: {
        DB_ENDPOINT_ADDRESS: dbInstance.dbInstanceEndpointAddress,
        DB_NAME: databaseName,
        DB_SECRET_ARN: dbInstance.secret?.secretFullArn || '',
      },
      vpc,
      vpcSubnets: vpc.selectSubnets({
        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
      }),
    });

Em seguida, no lambda, você pode obter o segredo real dinamicamente na função lambda, conforme mostrado abaixo:

export const handler = async (event: any, context: any): Promise<any> => {
    const host = process.env.DB_ENDPOINT_ADDRESS || '';
    const database = process.env.DB_NAME || '';
    const dbSecretArn = process.env.DB_SECRET_ARN || '';
    const secretManager = new AWS.SecretsManager({
      region: 'us-east-1',
    });
    const secretParams: AWS.SecretsManager.GetSecretValueRequest = {
      SecretId: dbSecretArn,
    };
    const dbSecret = await secretManager.getSecretValue(secretParams).promise();
    const secretString = dbSecret.SecretString || '';

    const { password } = JSON.parse(secretString);

}

O autor deste artigo escreveu um tutorial detalhado aqui sobre o mesmo tópico.

Digamos que você tenha alguma ferramenta .exe executável dependente do Windows. Você pode carregá-la em um bucket do S3. Você pode executar este binário com alguns parâmetros usando o AWS Lambda?

Essa é mais uma pergunta para garantir que você entende o ambiente de execução do AWS Lambda – especificamente, o sistema operacional que ele usa.

Não, você não seria capaz de fazer isso, pois o AWS Lambda usa o Linux como sistema operacional. O Linux não seria capaz de executar um binário dependente do Windows.

Como você reutilizaria código entre funções do AWS Lambda?

Existem duas maneiras de reutilizar o código em muitas funções do AWS Lambda:

• Usar as camadas do Lambda: você pode armazenar seu código ou lógica em camadas do lambda, que você pode reutilizar em diferentes funções do lambda.

Abaixo está um código de alto nível para criar e consumir camadas do lambda usando aws cdk:

    const logicLayer = new lambda.LayerVersion(this, 'logic-layer', {
      compatibleRuntimes: [
        lambda.Runtime.NODEJS_14_X,
        lambda.Runtime.NODEJS_16_X,
      ],
      layerVersionName: 'business-logic-layer',
      code: lambda.Code.fromAsset('src/layers/business-logic'),
      description: 'Business logic layer',
    });


    const lambdaWithLayer = new NodejsFunction(this, 'lambdaWithLayer', {
      entry: path.join(__dirname, '../src/lambdas', 'lambda.ts'),
      ...nodeJsFnProps,
      functionName: 'lambdaWithLayer',
      handler: 'handler',
      layers: [logicLayer, utilsLayer],
    });

• Usar monorepo: você pode usar mono repos e pacotes criados dinamicamente em tempo de implantação.

O que acontece com suas funções lambda se você excluir uma camada lambda?

Nesta pergunta, o entrevistador quer ver o quanto você entende de camadas lambda.

As funções lambda existentes que usam essa camada excluída continuarão a funcionar – pois as camadas lambda são mescladas com as funções lambda no momento da implantação.

Você, no entanto, não poderá criar uma nova função lambda usando essa camada lambda excluída.

Você pode aprender mais sobre camadas lambda aqui e eu escrevi um guia sobre o mesmo tópico aqui (ambas as referências em inglês).

Você pode aumentar o tamanho de um pacote de implantação se você usa camadas lambda?

Não, você não pode aumentar o tamanho do pacote de implantação se usar camadas lambda. O tamanho máximo de implantação de 50 MB compactado inclui o tamanho da função lambda e suas camadas lambda associadas.

Se você tiver uma grande base de código e quiser aumentar a implantação, poderá executar contêineres no AWS Lambda.

Posso pegar minha aplicação da web dockerizada existente e executá-la usando o Lambda?

Não. Você não pode pegar nenhuma aplicação do Express, Springboot ou .NET Core (ou qualquer outra aplicação) como está e colocá-la dentro do lambda.

Dito isso, saiba que existem algumas bibliotecas que permitem colocar aplicações que usam esses frameworks da web no AWS Lambda. Internamente, essas bibliotecas convertem essas aplicações da web em APIs compatíveis com o AWS Lambda. Você pode ver um desses exemplos aqui (em inglês).

Ao usar esses frameworks, o tamanho de suas funções lambda será maior e resultará em tempos de inicialização mais longos.

Lembre-se de que, mesmo ao usar contêineres com Lambda, a API de tempo de execução existente do Lambda permanece a mesma. O Lambda ainda vai:

• ser uma única função
• ser invocado por um evento ou manualmente
• ter um limite de tempo de 15 minutos.

Como você pode ver no código abaixo, não haverá alteração na API lambda. A vantagem de usar o Docker é que você pode usar pacotes grandes sem se preocupar com o tamanho.

import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';

export const handler = async (
  event: APIGatewayEvent,
  context: Context
): Promise<APIGatewayProxyResult> => {
  console.log(`Event: ${JSON.stringify(event, null, 2)}`);
  console.log(`Context: ${JSON.stringify(context, null, 2)}`);
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Running this handler from docker',
    }),
  };
};

e é assim que você o usa:

 const repo = ecr.Repository.fromRepositoryName(
      this,
      'dockerLambda',
      'docker-lambda'
    );

    const dockerLambda = new lambda.DockerImageFunction(
      this,
      'DockerLambdaFunction',
      {
        code: lambda.DockerImageCode.fromEcr(repo),
      }
    );

O autor deste artigo escreveu um tutorial passo a passo sobre execução de contêineres do Docker para sua aplicação em aws lambda aqui (em inglês).

Como você compartilha arquivos grandes entre funções lambda?

Você pode usar o Elastic File System (EFS) para compartilhar arquivos grandes entre diferentes funções.

Você pode criar um access point (em português, ponto de acesso) no EFS, criado com as permissões apropriadas, e usar esse access point em seu caminho de montagem em seu lambda.

Todos os arquivos gravados nesse caminho de montagem estarão acessíveis a todas as outras funções lambda, desde que tenham o caminho de montagem com as permissões apropriadas.

Abaixo vemos o diagrama lógico de alto nível sobre como usar o AWS Lambda com o Elastic File System (EFS):

Você pode ler sobre isso aqui (em inglês e um pouco antigo). O autor deste artigo escreveu um guia passo a passo prático mais recente aqui (em inglês) sobre EFS com funções Lambda.

Conclusão

Espero que este artigo tenha ajudado você a se preparar para entrevistas que envolvam o AWS Lambda.

Obrigado por ler até aqui. O autor também escreve sobre aws e tecnologias sem servidor em https://www.cloudtechsimplified.com (blog em inglês). Se estiver interessado, pode se inscrever no blog dele.

No crescente cenário de ameaças cibernéticas de hoje, é importante aprender a se proteger. Neste artigo, compartilharei minhas cinco ferramentas favoritas, que você pode usar para proteger sua privacidade on-line.

Por que a privacidade on-line é importante

Você já se perguntou sobre o valor de seus dados?

Todas as aplicações, sites e empresas vêm lutando para obter mais informações sobre você. Quanto mais souberem, melhor poderão prever o que você deseja. Às vezes, até mesmo antes de você.

A privacidade pessoal nos protege de possíveis danos ou invasões indesejadas em nossas vidas. Ela também nos permite manter nossa dignidade e autonomia.

Mais importante ainda, a privacidade pessoal é nosso direito fundamental. Sem ela, somos apenas pontos de dados usados para treinar um modelo de IA.

Os cínicos argumentam que "a privacidade pessoal é uma relíquia do passado". Na verdade, não.

No mundo faminto por dados de hoje, ainda é possível proteger sua privacidade e usar os ótimos produtos que a Internet oferece.⁠ Aqui estão cinco ferramentas que ajudarão você a proteger sua privacidade on-line.

Navegador Brave

O Brave é um navegador da web que se concentra em privacidade e segurança. Ele bloqueia anúncios de terceiros e rastreia cookies por padrão. Ele também permite que os usuários controlem quais anúncios veem e como seus dados são usados.

Aqui estão alguns dos principais recursos que diferenciam o navegador Brave:

• Privacidade: o Brave bloqueia anúncios de terceiros e cookies de rastreamento por padrão, o que ajuda a proteger sua privacidade on-line.
• Segurança: o Brave usa HTTPS Everywhere para atualizar sites inseguros para proteger conexões HTTPS. Isso ajuda a protegê-lo contra ataques man-in-the-middle e outras formas de vigilância on-line.
• Desempenho: o Brave usa a mesma tecnologia do Google Chrome –  o projeto de código aberto Chromium. Isso significa que ele é rápido, estável e tem suporte para os padrões da web mais recentes.
• Recompensas: o Brave permite que os usuários ganhem recompensas na forma do Basic Attention Token (BAT) por visualizar anúncios que respeitam a privacidade. Isso oferece aos usuários uma maneira de oferecer suporte aos sites que visitam e aos criadores de conteúdo de que gostam, sem precisar compartilhar seus dados com anunciantes.

O navegador Brave oferece uma combinação de privacidade, segurança e desempenho. Ele é uma alternativa mais segura ao Chrome ou Edge para proteger sua privacidade.

1Password

O 1Password é um gerenciador de senhas e uma carteira digital segura. É um programa de software que permite armazenar e gerenciar suas senhas, informações de cartão de crédito e outros dados confidenciais em um cofre criptografado e seguro.

Com o 1Password, você só precisa se lembrar de uma única senha mestra. Isso ajudará a facilitar o uso de senhas fortes e exclusivas para todas as suas contas on-line.

O 1Password está disponível em uma ampla variedade de dispositivos e plataformas, incluindo Windows, Mac, Linux, iOS e Android.

Existem outras alternativas para o 1Password, como o Lastpass e o LogMeOnce. Aqui, porém, vão algumas razões pelas quais o 1Password é uma escolha melhor:

• Segurança: o 1Password usa criptografia forte e padrão do setor para proteger seus dados. Possui muitos recursos de segurança para ajudar a impedir o acesso não autorizado ao seu cofre. Isso dará a você a tranquilidade de saber que todas as suas informações estão seguras e protegidas.
• Fácil de usar: o 1Password é fácil de usar. Possui uma interface simples e intuitiva e suporte para uma ampla variedade de dispositivos e plataformas. Ele também se integra ao seu navegador da web para que você possa salvar e preencher senhas enquanto navega na Internet.
• Recursos: O 1Password oferece uma variedade de recursos, incluindo a capacidade de gerar senhas fortes. O 1Password também pode armazenar informações de cartão de crédito e você pode optar por compartilhar senhas com outras pessoas, se necessário.

No geral, o 1Password oferece uma combinação de segurança, facilidade de uso, recursos e suporte que o tornam uma escolha popular entre os usuários de gerenciadores de senhas.

Privacy Badger

O Privacy Badger é uma extensão de navegador livre que ajuda a proteger sua privacidade on-line. É um produto da The Electronic Frontier Foundation (EFF). A EFF é uma organização sem fins lucrativos que defende os direitos digitais e as liberdades civis.

O Privacy Badger funciona detectando e bloqueando cookies de rastreamento de terceiros. Ele também analisa o comportamento de rastreadores de terceiros para ver quais deles estão rastreando você sem o seu consentimento. O Privacy Badger está disponível para os navegadores Chrome, Firefox e Opera.

Aqui estão algumas razões pelas quais o Privacy Badger é uma ótima ferramenta:

• É livre: o Privacy Badger é uma extensão de navegador livre e de código aberto, o que significa que você pode usá-la sem pagar nada.
• É simples: o Privacy Badger é fácil de usar, com uma interface simples e sem configurações complexas para configurar. Você pode simplesmente instalá-lo e deixá-lo fazer o seu trabalho.
• É eficaz: o Privacy Badger usa algoritmos avançados para detectar e bloquear o rastreamento de terceiros. Ele também tem a capacidade de aprender e se adaptar à medida que encontra novos rastreadores. Isso significa que pode ser eficaz em proteger sua privacidade sem exigir que você faça qualquer trabalho.
• É transparente: o Privacy Badger é desenvolvido pela EFF, uma organização conhecida e confiável na comunidade. A EFF publica regularmente relatórios e atualizações sobre o desenvolvimento e desempenho do Privacy Badger.

O Privacy Badger é uma maneira simples e eficaz de proteger sua privacidade on-line. Com uma interface simples e alimentada por algoritmos de IA, o Privacy Badger é uma ferramenta essencial para proteger sua privacidade.

Express VPN

A ExpressVPN é um serviço de rede virtual privada (VPN) que permite acessar a Internet com segurança.

A ExpressVPN criptografa seu tráfego e o encaminha por meio de um servidor remoto. Isso pode fazer parecer que você está navegando de um local diferente.

Isso é útil por vários motivos, inclusive para proteger sua privacidade. Você também pode acessar conteúdo restrito em sua região e contornar a censura na Internet.

A ExpressVPN é uma das muitas empresas que oferecem serviços de VPN, mas é conhecida por sua velocidade e confiabilidade.

Aqui estão algumas razões pelas quais a ExpressVPN é uma ótima escolha:

• Velocidade: a ExpressVPN é conhecida por suas velocidades rápidas, que facilitam o streaming de vídeos ou a reprodução de jogos on-line.
• Confiabilidade: a ExpressVPN tem a reputação de ser um serviço de VPN confiável e estável. A ExpressVPN possui uma grande rede de servidores e uma equipe de engenheiros trabalhando dia e noite para manter o serviço.
• Segurança: a ExpressVPN usa criptografia forte para proteger seus dados. Ela também oferece muitos recursos de segurança, como proteção contra vazamento de DNS, para ajudar a mantê-lo seguro on-line.
• Privacidade: a ExpressVPN tem uma política estrita de não manter registros. Isso significa que ela não coleta nem armazena informações sobre sua atividade on-line. Isso dará a você a tranquilidade de saber que sua privacidade está protegida.
• Compatibilidade: a ExpressVPN está disponível em uma ampla variedade de dispositivos e sistemas operacionais. Isso inclui Windows, Mac, Linux, Android e iOS. Ela também oferece aplicações de VPN personalizadas para roteadores, consoles de jogos e outros dispositivos.

A ExpressVPN oferece uma combinação de velocidade, confiabilidade, segurança, privacidade e compatibilidade. Isso a torna uma escolha popular entre os usuários de VPN.

HaveIBeenPawned

Have I Been Pwned (HIBP) é um site que ajuda você a verificar se suas informações pessoais foram expostas a uma violação de dados.

O pesquisador de segurança Troy Hunt criou o HIBP em 2013. Desde então, ele se tornou um recurso amplamente utilizado para verificar informações pessoais comprometidas.

Se o HIBP descobrir que suas informações estão expostas, ele recomendará as medidas que você pode tomar para se proteger. Isso pode incluir alteração de senhas, ativação da autenticação de dois fatores e assim por diante.

Aqui estão alguns recursos do HIBP:

• Pesquisa por violação de dados: você pode inserir seu endereço de e-mail ou nome de usuário para ver se ele foi incluído em alguma das violações de dados no banco de dados do HIBP.
• Serviço de notificação: você pode se inscrever no serviço de notificação do HIBP, que o alertará se seu endereço de e-mail aparecer em uma nova violação de dados.
• Pesquisa por senha violada: você pode inserir uma senha para ver se ela apareceu em alguma violação de dados. Isso pode ajudá-lo a determinar se uma senha é segura ou se você deve alterá-la.
• API Pwned Password: o HIBP oferece uma API que permite aos desenvolvedores usar o recurso de pesquisa de senha violada em suas próprias aplicações.
• Estatísticas de violação de dados: o HIBP fornece estatísticas sobre violações de dados. Isso inclui o número de registros comprometidos e os tipos de dados que foram expostos.

Mesmo se você definir uma senha forte, as aplicações que você usa podem encontrar uma violação de dados. O HIBP ajuda você a acompanhar essas violações e garantir que seus dados estejam seguros.

Resumo

A privacidade on-line não é um mito. Existem ótimas ferramentas que podemos usar para proteger nossa vida digital e usar a Internet com segurança.

Use essas cinco ferramentas além das práticas de segurança padrão, como definir senhas fortes e habilitar a autenticação de dois fatores. Neste artigo, vemos algumas dicas sobre como se manter seguro on-line.

Gostou deste artigo? Visite https://www.stealthsecurity.io/ para encontrar mais conteúdo de segurança cibernética (em inglês). Você também pode se conectar com o autor pelo LinkedIn.

Os chatbots automatizados são bastante úteis para estimular interações. Podemos criar chatbots para o Slack, o Discord e outras plataformas.

Neste artigo, vou ensinar a você como construir um chatbot do Telegram que vai dizer o seu horóscopo. Então, vamos começar!

Como obter seu token de bot

Para configurar um novo bot, você precisará falar com o BotFather. Não, ele não é uma pessoa – ele também é um bot e é o chefe de todos os bots do Telegram.

1. Procure por @botfather no Telegram.

2.  Comece uma conversa com o BotFather clicando no botão Iniciar (ou Start, na versão em inglês).

3.  Digite /newbot e siga as instruções para configurar um novo bot. O BotFather dará a você um token que você usará para autenticar seu bot e conceder a ele acesso à API do Telegram.

Observação: não se esqueça de armazenar o token de modo seguro. Qualquer pessoa com acesso ao seu token pode facilmente manipular seu bot.

Como configurar seu ambiente de programação

Vamos configurar o ambiente de programação. Embora existam várias bibliotecas disponíveis para criar um bot do Telegram, usaremos a biblioteca pyTelegramBotAPI. É uma implementação simples, mas extensível, do Python para a API de bots do Telegram, com recursos síncronos e assíncronos.

Instale a biblioteca pyTelegramBotAPI usando o pip:

pip install pyTelegramBotAPI

Em seguida, abra seu editor de código favorito e crie um arquivo .env para armazenar seu token conforme abaixo:

export BOT_TOKEN=token-do-seu-bot-aqui

Depois disso, execute o comando source .env para ler as variáveis de ambiente a partir do arquivo .env.

Como criar seu primeiro bot

Todas as implementações da API são armazenadas em uma única classe chamada TeleBot. Ela oferece muitas maneiras de ouvir mensagens recebidas, bem como funções como send_message(), send_document() e outras para enviar mensagens.

Crie um arquivo bot.py e cole o seguinte código lá:

import os

import telebot

BOT_TOKEN = os.environ.get('BOT_TOKEN')

bot = telebot.TeleBot(BOT_TOKEN)

No código acima, usamos a biblioteca os para ler as variáveis de ambiente armazenadas em nosso sistema.

Lembre-se: exportamos uma variável de ambiente chamada BOT_TOKEN na etapa anterior. O valor de BOT_TOKEN é lido em uma variável também chamada BOT_TOKEN. Além disso, usamos a classe TeleBot para criar uma instância de bot e passamos o BOT_TOKEN para ela.

Em seguida, precisamos registrar manipuladores de mensagens. Esses manipuladores de mensagens contêm filtros pelos quais uma mensagem deve passar. Se uma mensagem passar pelo filtro, a função decorada é chamada e a mensagem recebida é fornecida como um argumento.

Vamos definir um manipulador de mensagens que manipule os comandos /start e /hello recebidos.

@bot.message_handler(commands=['start', 'hello'])
def send_welcome(message):
    bot.reply_to(message, "Howdy, how are you doing?")

Qualquer nome é aceitável para uma função decorada por um manipulador de mensagens, mas só pode ter um parâmetro (a mensagem).

Vamos adicionar outro manipulador que ecoa todas as mensagens de texto recebidas de volta ao remetente.

@bot.message_handler(func=lambda msg: True)
def echo_all(message):
    bot.reply_to(message, message.text)

O código acima usa uma expressão lambda para testar uma mensagem. Como precisamos ecoar todas as mensagens, sempre retornamos True na função lambda.

Agora você tem um bot simples, que responde aos comandos /start e /hello com uma mensagem estática e que ecoa todas as outras mensagens enviadas. Adicione o seguinte ao final do seu arquivo para iniciar o bot:

bot.infinity_polling()

É isso! Temos um bot do Telegram pronto. Vamos executar o arquivo Python e ir ao Telegram para testar o bot.

Pesquise o bot usando seu nome de usuário se não conseguir encontrá-lo. Você pode testá-lo enviando comandos como /hello e /start e outros textos aleatórios.

Observação: todos os manipuladores de mensagens são testados na ordem em que foram declarados no arquivo-fonte.

Para obter mais informações sobre como usar a biblioteca pyTelegramBotAPI, consulte sua documentação.

Como programar o Horoscope Bot

Vamos mudar nossa atenção para a construção de nosso Horoscope Bot agora. Usaremos o encadeamento de mensagens no bot. O bot primeiro perguntará pelo seu signo do zodíaco, o dia e, em seguida, responderá com o horóscopo desse dia específico.

Internamente, o bot interage com uma API para obter os dados do horóscopo.

Vamos usar a API Horoscope que criei em outro tutorial. Se você deseja aprender como criar uma API, pode ler este tutorial (em inglês). Certifique-se de explorar a API de horóscopo aqui antes de começar.

Como obter os dados de horóscopo

Vamos criar uma função utilitária para obter os dados de horóscopo para um dia específico.

import requests

def get_daily_horoscope(sign: str, day: str) -> dict:
    """Get daily horoscope for a zodiac sign.
    Keyword arguments:
    sign:str - Zodiac sign
    day:str - Date in format (YYYY-MM-DD) OR TODAY OR TOMORROW OR YESTERDAY
    Return:dict - JSON data
    """
    url = "https://horoscope-app-api.vercel.app/api/v1/get-horoscope/daily"
    params = {"sign": sign, "day": day}
    response = requests.get(url, params)

    return response.json()

No código Python acima, criamos uma função que aceita dois argumentos de string – sign e day – e retorna dados JSON. Enviamos uma solicitação GET ao URL da API e passamos sign e day como parâmetros de consulta.

Se você testar a função, obterá um resultado semelhante ao que vemos abaixo:

{
   "data":{
      "date": "Dec 15, 2022",
      "horoscope_data": "Lie low during the day and try not to get caught up in the frivolous verbiage that dominates the waking hours. After sundown, feel free to speak your mind. You may notice that there is a sober tone and restrictive sensation today that leaves you feeling like you will never be able to break free from your current situation. Don't get caught in this negative mindset."
   },
   "status": 200,
   "success": true
}

Observação: você pode saber mais sobre a biblioteca requests do Python neste tutorial (em inglês).

Como adicionar um manipulador de mensagens

Agora que temos uma função que retorna os dados do horóscopo, vamos criar um manipulador de mensagens em nosso bot que pergunte o signo do zodíaco do usuário.

@bot.message_handler(commands=['horoscope'])
def sign_handler(message):
    text = "What's your zodiac sign?\nChoose one: *Aries*, *Taurus*, *Gemini*, *Cancer,* *Leo*, *Virgo*, *Libra*, *Scorpio*, *Sagittarius*, *Capricorn*, *Aquarius*, and *Pisces*."
    sent_msg = bot.send_message(message.chat.id, text, parse_mode="Markdown")
    bot.register_next_step_handler(sent_msg, day_handler)

A função acima é um pouco diferente das outras funções que definimos anteriormente. A funcionalidade de horóscopo do bot será invocada pelo comando /horoscope. Estamos enviando uma mensagem de texto para o usuário, mas observe que definimos o parse_mode como Markdown ao enviar a mensagem.

Como usaremos encadeamento de mensagens, usamos o método register_next_step_handler(). Esse método aceita dois parâmetros: a mensagem enviada pelo usuário e a função de callback que deve ser chamada após a mensagem. Assim, passamos a variável sent_msg e uma nova função day_handler, que definiremos a seguir.

Vamos definir a função day_handler(), que aceita a mensagem.

def day_handler(message):
    sign = message.text
    text = "What day do you want to know?\nChoose one: *TODAY*, *TOMORROW*, *YESTERDAY*, or a date in format YYYY-MM-DD."
    sent_msg = bot.send_message(
        message.chat.id, text, parse_mode="Markdown")
    bot.register_next_step_handler(
        sent_msg, fetch_horoscope, sign.capitalize())

Buscamos o signo do zodíaco do atributo message.text. Semelhante à função anterior, ela também pergunta o dia para o qual você deseja saber o horóscopo.

No final, usamos o mesmo método register_next_step_handler() e passamos sent_msg, a função de callback fetch_horoscope e o sign.

Vamos, agora, definir a função fetch_horoscope(), que aceita a mensagem e o signo.

def fetch_horoscope(message, sign):
    day = message.text
    horoscope = get_daily_horoscope(sign, day)
    data = horoscope["data"]
    horoscope_message = f'*Horoscope:* {data["horoscope_data"]}\\n*Sign:* {sign}\\n*Day:* {data["date"]}'
    bot.send_message(message.chat.id, "Here's your horoscope!")
    bot.send_message(message.chat.id, horoscope_message, parse_mode="Markdown")

Essa é a função final, onde obtemos o signo no parâmetro de função e o dia do atributo message.text.

Em seguida, buscamos o horóscopo usando a função get_daily_horoscope() e criamos nossa mensagem. No final, enviamos a mensagem com os dados do horóscopo.

Demonstração do bot

Depois de executar o arquivo Python, você pode testar essa funcionalidade. Aqui está a demonstração:

Próximos passos recomendados

A partir de agora, o bot para de funcionar assim que paramos nossa aplicação do Python. Para fazê-lo funcionar sempre, você pode implantar o bot em plataformas como o Heroku, o Render e assim por diante.

Aqui está um link do repositório no GitHub para esse projeto - sinta-se à vontade para conferir.

Você também pode adicionar mais funcionalidades ao bot explorando as APIs do Telegram.

Obrigado pela leitura! Se quiser, você pode seguir o autor no Twitter.

Qualquer pessoa deve poder usar os sites e aplicações que você cria – pessoas com ou sem deficiência. Isso é o que tornará o seu site acessível.

Pense no último site que você construiu ou no seu site favorito. Você tem certeza de que qualquer pessoa pode usar seu site e executar as ações críticas necessárias? Você já considerou pessoas com deficiência motora, deficiência visual, deficiência cognitiva e deficiência auditiva?

A acessibilidade é muitas vezes deixada de lado e tratada como uma reflexão tardia. Quando chega a hora de enviar um recurso, fazemos um teste de acessibilidade e descobrimos que nosso site não estava acessível, corrigindo tudo com gambiarras.

Tornar um site acessível é um grande empreendimento. Se, no entanto, mantivermos a acessibilidade em mente desde o início, será muito mais fácil criar um aplicação para a web acessível.

Neste artigo, abordarei 5 coisas que você deve ter em mente DURANTE a criação da sua aplicação para não ter que dar "aquele ajuste" no final.

5 coisas para se lembrar para ter uma boa acessibilidade

1. HTML Semântico
2. Tabindex
3. Atributos Aria
4. Roles (funções)
5. Navegação por teclado (do inglês, Keyboard) e leitores de tela

Em resumo, S.T.A.R.K.

Se você precisar de ajuda para se lembrar disso, pense no Tony Stark.

Vamos examinar cada um deles para entender como usá-los em suas aplicações para a web.

O que é o HTML semântico?

O uso de HTML semântico é importante para a acessibilidade. Isso ocorre porque tecnologias assistivas, como leitores de tela, são capazes de interpretar o que está na página analisando o HTML da página. Ele permite que os usuários executem ações com base nos elementos.

Por exemplo, se um leitor de tela encontra um botão, ele sinaliza ao usuário que deve clicar nele.

Vamos considerar alguns casos de uso do que pode acontecer quando você não usa HTML semântico:

Criar botões usando div em vez de button:

divs são elementos contêineres. Portanto, quando um leitor de tela encontra uma div, ele pensa automaticamente que é um elemento da apresentação.

Quando um usuário de leitor de tela encontra um elemento div que tem conteúdo ou filhos dentro dele, o leitor de tela anuncia role="group" e o usuário não perceberá que a div é interativa. Portanto, certifique-se de usar o elemento semântico adequado para sua finalidade. Você obtém acessibilidade gratuitamente.

Usar CSS para falsificar títulos em vez de usar as tags h1-6:

Tags de títulos, como <h1> e <h2>, permitem que uma tecnologia assistiva saiba que este é um texto importante e o leitor de tela anunciará "Título".

Quando você usa o CSS para fazer um título em vez de usar o HTML semântico correto, o significado do texto é perdido para um leitor de tela.

Portanto, certifique-se de usar HTML semântico sempre que possível.

O que é tabindex?

Adicionar um tabindex torna os elementos interativos navegáveis pelo teclado. Quando você adiciona um tabindex a um elemento, um usuário pode navegar até ele usando apenas o teclado e/ou tecnologias assistivas.

1. Você usa um tabindex de 0 para definir o foco para um elemento na ordem de tabulação padrão,
2. Você usa um tabindex de -1 para focar programaticamente um elemento usando JavaScript.
3. Não atribua um valor >1 a tabindex.

Um aviso importante – você só deve adicionar tabindex a elementos interativos. Não é uma boa prática adicionar tabindex a elementos como divs.

Em vez de adicionar tabindex, nesse caso, use um elemento semântico, como um button, pois os elementos semânticos já podem ser tabulados e não precisam de um valor tabindex adicional.

O que são atributos ARIA?

Atributos Aria, como aria-checked e aria-label, fornecem informações adicionais para tecnologias assistivas.

Os atributos Aria são um conjunto de atributos do HTML que você usa para fornecer informações adicionais sobre a finalidade e o estado dos elementos em uma página da web. Esses atributos são especialmente benéficos para tecnologias assistivas para fornecer mais contexto e melhor navegação para os usuários.

Alguns atributos Aria comuns incluem:

1. aria-label: usado para fornecer um rótulo ou nome para um elemento.
2. aria-hidden: usado para indicar que um elemento deve ser ocultado das tecnologias assistivas. Isso pode ser útil para elementos usados para fins de layout, mas não relevantes para o conteúdo da página.
3. aria-describedby: usado para associar um elemento a uma descrição, o que ajuda a fornecer o contexto de um elemento.
4. aria-live: usado para indicar que o conteúdo de um elemento pode mudar dinamicamente e que as tecnologias assistivas devem prestar atenção às mudanças no conteúdo do elemento.

Você pode usar esses atributos em combinação entre si e com atributos HTML padrão para criar conteúdo para a web mais acessível e fácil de usar.

O que é o atributo aria-role?

Você usa o atributo aria-role para definir a finalidade de um elemento HTML e fornecer seu significado semântico.

Por exemplo, se estiver construindo um componente de grade (grid) com a ajuda de CSS e divs, você pode usar role="grid" para permitir que as tecnologias assistivas saibam sobre a semântica do componente.

Alguns aria-roles comuns incluem:

1. button: usado para indicar que um elemento deve ser tratado como um botão.
2. alert: usado para indicar que um elemento é uma caixa de alerta.
3. presentation: usado para indicar que um elemento é apenas de apresentação.

É importante ter cuidado com aria-role. Lembre-se de não exagerar.

Como tratar da navegação por teclado e leitores de tela

Muitos usuários com deficiência motora dependem de seu teclado e tecnologias assistivas para navegar na web. Portanto, é fundamental que cada componente seja navegável usando um teclado e um leitor de tela.

Você pode testar a acessibilidade do teclado navegando em um site usando apenas o teclado. Aqui estão algumas teclas comuns:

1. a tecla tab ajuda a navegar pelas diferentes seções do site.
2. a barra de espaço ajuda a selecionar elementos, como uma caixa de seleção.
3. a tecla enter serve para pressionar os botões.

Ao testar a navegação por teclado, certifique-se de pensar no seguinte:

1. O foco permanece visível: verifique se você pode ver claramente qual elemento está sendo focado na página. O foco deve permanecer sempre visível.
2. Ordem das tabulações: ao percorrer as seções, a ordem das tabulações deve seguir o fluxo natural e a estrutura lógica do site. Ele não deve pular para frente e para trás entre as seções.
3. Armadilhas do teclado: certifique-se de que, ao navegar com o teclado, o foco não fique preso em um elemento. Por exemplo, isso pode acontecer quando um modal é aberto ou o foco é navegado para um widget, como um calendário ou o seletor de emojis. Certifique-se de que, ao selecionar um elemento no widget, você possa navegar de volta ao site.

Resumo

Em geral, testar a acessibilidade durante o desenvolvimento é uma parte importante do processo que pode ajudar a criar um software mais utilizável e acessível para todos os usuários. Testar a acessibilidade com antecedência ajuda a fornecer uma ótima experiência de usuário para todos.

No próximo artigo, a autora fala sobre as várias ferramentas de acessibilidade e sobre como depurar um problema de acessibilidade. Você pode se inscrever para recebê-lo em sua caixa de entrada aqui.

Até lá, boa programação para você!

A tecnologia está sempre melhorando e os desenvolvedores estão sempre tentando encontrar maneiras mais fáceis e melhores de melhorar o software. Foi assim que surgiu o DevOps e, logo, o DevTestOps surgiu como uma nova estratégia.

Hoje, empresas como o Spotify aplicam o DevTestOps na produção de software, o que facilita a atualização, o teste e a implantação de qualquer alteração com rapidez e facilidade.

Neste artigo, veremos o DevTestOps, seus objetivos e processos. Também veremos como começar a usar o DevTestOps, as práticas recomendadas e por que uma empresa deve adotar o DevTestOps.

Antes de mergulharmos no DevTestOps, vamos ver o que são DevOps e TestOps e como eles funcionam.

O que são DevOps e TestOps?

DevOps é uma combinação de Desenvolvimento e Operações. O DevOps foi introduzido no ciclo de vida do desenvolvimento de software devido à necessidade de desenvolvimento contínuo do produto. Ele ajuda as equipes a integrar e implantar atualizações de software com mais facilidade.

O TestOps envolve a realização de grandes conjuntos de testes de automação em software para que ele seja altamente eficiente com menos bugs.

Inicialmente, o DevOps foi introduzido em equipes de software que permitiam a colaboração apenas entre desenvolvedores e operadores. Em seguida, os testadores passaram a realizar os testes ao final do desenvolvimento.

No entanto, isso trouxe alguns desafios para a equipe, especialmente depois de trabalhar em algum software e concluir que estava pronto para produção – apenas para os testadores executarem o software e descobrirem bugs complexos. Foi por meio desses desafios que o DevTestOps surgiu.

O que é DevTestOps?

DevTestOps é um padrão que é parte do ciclo de vida de desenvolvimento de software e que inclui testes, integração e implantação contínuos.

No DevTestOps, você testa o produto em diferentes estágios de desenvolvimento, o que ajuda a reduzir o número de bugs em estágios posteriores.

No DevTestOps, as equipes de desenvolvimento, teste e operações trabalham lado a lado para garantir a qualidade e o teste adequado do produto.

Isso resulta em entrega rápida, com poucos ou nenhum bug no final do ciclo de vida de desenvolvimento de software.

O DevTestOps surgiu como uma versão aprimorada do DevOps com o TestOps incluído. Isso facilita a criação, implantação e desenvolvimento de produtos de qualidade com menos bugs.

Objetivos do DevTestOps

O DevTestOps tem objetivos que são chamados de manifestos. Os manifestos definem os objetivos que você espera alcançar.

De acordo com o site mabl.com (tradução nossa):

"Existem cinco manifestos de DevTestOps, que incluem:
- Teste contínuo em vez de teste no final.
- Privilegiar a adoção de todas as atividades de teste em vez de apenas aquelas dos testes funcionais automatizados.
- Privilegiar o teste do que agrega valor em vez de testar tudo.
- Privilegiar o teste por toda a equipe em vez de testes em departamentos de teste isolados.
- Cobertura do produto em vez de cobertura de código." (Fonte: mabl.com)

Como o DevTestOps funciona

Existem várias etapas do processo DevTestOps. Elas são:

1. Planejar: nesta etapa, você define os detalhes do produto e faz uma verificação cruzada para garantir que tudo esteja alinhado com o mercado.
2. Construir: nesta etapa, você constrói o programa e o carrega no repositório, realiza testes de unidade e, se o programa não apresentar erros, ele se torna a base de código. Você pode adicionar possíveis atualizações (sugestões ou melhorias) antes de passar para a próxima etapa.
3. Testar: nesta etapa, você executa e analisa todos os casos de teste. Você pode fazer atualizações subsequentes e testar o programa novamente antes de entregá-lo e considerá-lo pronto para implantação.
4. Lançar: você inicia o produto e testa outras atualizações escritas antes de adicioná-lo à base de código.
5. Monitorar: você verifica constantemente o produto em busca de feedback e problemas que são tratados e atualizados imediatamente.

Como dar os primeiros passos com o DevTestOps:

Muitas organizações já usam o DevOps, mas continuam produzindo software com bugs. Se você quiser mudar para DevTestOps para tentar reduzir os bugs em seu código, abiaxo vemos algumas etapas que você pode seguir.

Adicione testes contínuos ao seu roteiro ou guia de DevOps:

O DevTestOps tem uma cultura semelhante ao DevOps, exceto pelo fato de que você adiciona testes contínuos. Os testadores devem se tornar parte da equipe de DevOps para que possam testar o software imediatamente após uma atualização.

Crie uma cadeia de ferramentas de DevTestOps:

Uma cadeia de ferramentas inclui todas as ferramentas necessárias para implementar o DevTestOps. Por exemplo, sua cadeia de ferramentas pode incluir ferramentas como Jira, Kubernetes, Selenium, GitHub, Jenkins e muito mais.

Você pode atribuir funções a diferentes equipes usando essas ferramentas para que possam trabalhar de modo eficaz com elas.

Implemente as ferramentas em sua organização:

Em seguida, você precisará ensinar as equipes a implementar essas ferramentas e a seguir as estratégias que você implementou para a produção de software.

Você pode adicionar funções de teste a cada equipe, o que transformará a cultura de trabalho e incentivará a colaboração entre os desenvolvedores, testadores e operadores de cada equipe.

Automatize:

Você deve aplicar a automação em cada um desses processos, desde a fase de construção até a fase de implantação. Isso ajudará todos os desenvolvedores e testadores a trabalhar com mais eficiência.

Faça melhorias constantes:

Finalmente, você pode atualizar constantemente as ferramentas e processos para acomodar tendências e atualizações relevantes no espaço tecnológico.

Melhores práticas para o DevTestOps:

Aqui estão algumas práticas recomendadas que você pode seguir para implementar o DevTestOps em sua equipe:

• Use as ferramentas e frameworks certas para integração, teste, entrega e implantação. Isso vai depender do que funciona melhor para a organização.
• Aplique automação em testes, implantação e até mesmo em outros estágios. A automação ajudará a acelerar o processo e facilitará que as equipes produzam mais rapidamente e cumpram os prazos.
• Todas as equipes devem se comunicar de modo eficaz. Eles devem promover a colaboração entre as equipes para aumentar a compreensão, o que aumentará a produtividade e eliminará a confusão.
• O pipeline que compreende integração contínua, teste, entrega e implantação deve ser sempre monitorado. Se você identificar um problema, as equipes podem fazer alterações e integrar as atualizações imediatamente.

Por que você deve adotar o DevTestOps?

Existem muitos motivos para adotar o DevTestOps. Primeiro, melhora a qualidade do código.

Ele também melhora a colaboração entre desenvolvedores, testadores e operadores. Como diz o manifesto, o teste não é mais feito em departamentos de teste isolados, mas em cada fase.

Além disso, ele economiza tempo gasto na correção de bugs ao testar no final, em vez de em cada estágio.

Por fim, ele facilita a integração e a implantação contínuas.‌‌

Conclusão

Em um mundo de constantes melhorias em tecnologia, as empresas devem aprimorar continuamente seus softwares para atenderem aos padrões do mercado.

Com o DevTestOps, fica mais fácil para as equipes de software fazerem atualizações e melhorarem seus produtos para atender aos padrões do mercado.

Recursos (todos em inglês):

• DevOps Advantages And Best Practices | Quick Guide
• What Is DevTestOps And How Can It Transform Agile
• What Is DevOps Orchestration For Agile Teams?

Infraestrutura como código (ou, em inglês, infrastructure as a code, ou IaC) é o processo de provisionamento e gerenciamento de seus recursos de nuvem escrevendo um arquivo de modelo que pode ser lido por humanos e consumível pela máquina.

Para o desenvolvimento na nuvem com a AWS, a escolha integrada para infraestrutura como código é o AWS CloudFormation.

Usando a IaC, os desenvolvedores podem gerenciar a infraestrutura de um projeto com eficiência, permitindo que eles configurem e mantenham facilmente as alterações na arquitetura e nos recursos de um projeto.

Existem inúmeras ferramentas de IaC disponíveis, como Ansible, Puppet, Chef e Terraform.

Para este guia, no entanto, usaremos o CloudFormation, que foi feito especificamente para os recursos da AWS.

O que você vai aprender neste tutorial

Depois de passar por este tutorial, você entenderá como manter seus recursos em um arquivo de software.

Além disso, você aprenderá os benefícios relacionados à velocidade que a infraestrutura como código traz. Sem a IaC, o tempo e o custo da implantação manual de várias infraestruturas podem ser muito maiores em comparação com a manutenção da infraestrutura como software.

Neste artigo, vamos considerar um exemplo. Ele demonstrará o provisionamento manual de recursos versus a implantação de um script CloudFormation para criar uma função Lambda sem servidor e uma API REST na AWS.

Serviços que vamos usar neste tutorial

Vamos usar os seguintes serviços para implementar infraestrutura como código na AWS:

Para quem é novo na AWS, é bom ter algum conhecimento dela para entender o artigo. Então, você pode me acompanhar criando uma conta na AWS aqui e certificando-se de ter a AWS CLI instalada para trabalhar com o exemplo.

Visão geral do exemplo

Para o artigo, implementaremos uma API REST com um gateway de API. Ele será integrado a uma função Lambda de back-end sem servidor que lida com POST e obtém solicitações feitas por nossa API.

A primeira etapa mostrará como criar e implantar manualmente esses recursos usando o console AWS. A segunda etapa mostrará como automatizar o processo usando o CloudFormation.

Como implantar manualmente

Na implantação (ou, em inglês, deployment) manual, trabalharemos dentro do console AWS. É um pouco difícil acompanhar as alterações ao trabalhar fora do IDE local, especialmente para projetos de grande escala.

Na primeira etapa, criaremos uma função Lambda.

Se você deseja que sua função Lambda funcione com algum outro serviço como o Comprehend, deve conceder permissões para esse serviço. Portanto, certifique-se de criar uma função com essas permissões.

A seguir está nossa função Lambda que retornará "Hello World" quando integrada ao gateway da API.

import json

def lambda_handler(event, context):
    # TODO implement
    return {
        'statusCode': 200,
        'body': json.dumps('Hello World!')
    }

Agora que configuramos nossa função Lambda, a próxima etapa é criar uma API REST para interagir com a função Lambda.

Para isso, vá para o Amazon API Gateway, clique em "Create API" (Criar API) e selecione REST API nas opções fornecidas.

Agora, vamos integrar o Lambda com a API. Para isso, crie um método GET no menu de ações e aponte nossa API REST para a função Lambda.

Estamos em condições de implantar e testar nossa API para sua integração adequada com o Lambda. Selecione o nome que desejar – para este exemplo, estou usando "prod".

Depois de implantar a API, você pode ver um URL no estágio "prod". Atingir esse URL acionará a função Lambda. Como retornamos "Hello World" a partir de nossa função Lambda, você poderá ver o resultado desejado.

Como implantar com CloudFormation

Até aqui, vimos como funciona a implantação manual, que costuma levar alguns minutos.

Vamos imaginar, no entanto, que temos mais de uma API, método e mais de um desenvolvedor trabalhando neles. Nesse cenário, rastrear todos os recursos e mudanças seria um desafio.

Portanto, nesta seção, usaremos o AWS CloudFormation. Ele dará flexibilidade aos desenvolvedores, permitindo que eles ajustem sua infraestrutura com um script simples.

Como o CloudFormation funciona?

Usaremos o arquivo YAML para provisionar e declarar esses recursos e implantá-los na AWS para criar uma stack do CloudFormation. O CloudFormation é uma stack que contém todos os recursos necessários para o projeto.

Usaremos o modelo SAM, conforme descrito acima na seção de serviços. É uma abstração do CloudFormation para criar aplicações sem servidor com menos código YAML.

Para quem não conhece o YAML, você pode pensar nele como se fosse um JSON. O CloudFormation, porém, usa esses dois formatos de arquivo.

Na primeira etapa, vamos para nosso IDE local e escrevemos a mesma função Lambda que escrevemos no console da AWS.

helloworld.py:

import json

def lambda_handler(event, context):
    # TODO implementar
    return {
        'statusCode': 200,
        'body': json.dumps('Hello World!')
    }

Em seguida, criaremos um arquivo template.yaml contendo nossa infraestrutura. Definiremos nossa função Lambda e API Gateway neste arquivo.

Para criar este arquivo, precisamos adicionar algumas informações que são comuns a todos os modelos SAM.

template.yaml:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: First CloudFormation template

Agora, temos que adicionar "Globals" a este arquivo template.yaml do CloudFormation. Globals são as configurações comuns para os recursos que você vai implantar. Globals permitem que você declare informações globalmente para um tipo de recurso específico, em vez de especificá-las repetidas vezes para recursos diferentes.

template.yaml:

Globals:
    #Comum a todas as funções Lambda que você cria
    Function:
      MemorySize: 128
      Runtime: python3.6
      Timeout: 5

Temos que definir a tag Resources em nosso arquivo template.yaml. A função Lambda e a API REST estarão sob esta tag.

template.yaml:

Resources:

    ##Lambda e API GW integrados
    helloworld:
        Type: AWS::Serverless::Function
        Properties:
          #nome_de_arquivo.nome_da_função
          Handler: helloworld.lambda_handler

          #REST API criada
          Events:
            PostAdd:
              Type: Api
              Properties:
                Path: /helloworld
                Method: get

No código acima, definimos parâmetros para criar a função Lambda. Para o evento, criamos uma API REST que aciona a função Lambda.

Observação: há alguns parâmetros, como CodeURI e description, que você pode especificar para sua função serverless. A melhor maneira de criar um arquivo de modelo é consultar os documentos do CloudFormation e ver os parâmetros disponíveis para seu recurso/serviço especificado.

Como implantar o arquivo de modelo

Podemos implantar nosso arquivo template.yaml usando os dois comandos da AWS CLI a seguir:

##s3 bucket armazena o modelo sam que precisamos implantar
aws cloudformation package --template-file template.yaml --output-template-file sam-template.yaml --s3-bucket helloworld-sam

Depois de executar o comando acima, você poderá ver um arquivo de modelo SAM. Usaremos esse arquivo no segundo comando abaixo.

Neste comando, forneça o caminho apropriado para o arquivo sam-template.yaml:

#Implantar a stack
#aponta para o arquivo modeleo criado por um comando anterior e um nome da stack, bem como a região na qual estamos implantando

aws cloudformation deploy --template-file /path to sam-template.yaml file --stack-name test-stack --capabilities CAPABILITY_IAM --region us-east-1

Depois de executar esses dois comandos, você verá a stack criada na CLI. Você pode verificá-la usando o CloudFormation no console.

Aqui você verá todos os recursos provisionados por meio do código criado e implantado usando o arquivo template.yaml.

Você pode clicar na API e acessar o URL para verificar a saída, como fizemos para a implantação manual.

Resumo

Era isso! Você implementou com sucesso a infraestrutura como código na AWS usando o CloudFormation.

Espero que este artigo tenha sido útil para quem deseja entender a implementação de infraestrutura como código na AWS.

Conecte-se com o autor do artigo pelo LinkedIn e pelo Twitter.

Até a próxima! 🙂

Um código de resposta rápida, ou quick response (QR), é um código de barras que um dispositivo digital pode escanear facilmente. Ele codifica os dados como uma série de pixels em uma grade quadrada.

Acompanhar informações sobre cadeias de suprimentos usando códigos QR é muito útil em campanhas de marketing e publicidade.

A International Organization for Standardization (ISO) certificou os códigos QR como um padrão global em 2000. Eles são uma melhoria em relação aos códigos de barras unidimensionais anteriores.

Os códigos QR foram desenvolvidos na década de 1990 para fornecer mais informações do que um código de barras comum. Eles foram criados pela Denso Wave, afiliada da Toyota, para monitorar a produção de veículos.

Ao contrário dos códigos de barras, que precisam de um feixe de luz para refletir as linhas paralelas, os códigos QR podem ser escaneados digitalmente por dispositivos como smartphones.

Os códigos QR são usados em sistemas de criptomoeda para permitir pagamentos digitais, como ao exibir um endereço Bitcoin. Os códigos QR também costumam ser usados para comunicar URLs de sites a dispositivos móveis.

Neste artigo, usaremos a biblioteca segno para criar belos códigos QR que executam muitas funções.

O que é o Segno?

O Segno é um gerador de código QR de código aberto que permite criar códigos QR regulares e micro com muito pouco esforço. Ele também não possui dependências.

O Segno oferece alguns tipos de serialização, como SVG, EPS, PNG, PDF e saída de texto. Nenhum desses serializadores chama uma biblioteca externa. Por meio de um design de plug-in, o Segno oferece outros tipos de serialização. PyPy e Python versões 2.6 a 3.4 foram usadas para teste.

Como instalar o Segno

Assim como qualquer outra biblioteca Python, você pode instalar o Segno via pip.

pip install segno

Como criar um código QR

Então, usando o método .make(), vamos começar fazendo o código QR mais básico possível. Como o conteúdo é tão pequeno, o Segno gera automaticamente um código "micro QR" de tamanho reduzido, que carrega dados brutos e que você pode copiar ou transferir.

import segno

price_tag = segno.make("Hello World")
price_tag.save("hello-world.png")

O código QR é gerado e salvo em nosso diretório de projetos.

Podemos adicionar uma borda ao código QR para torná-lo mais atraente. Você pode fazer isso adicionando o parâmetro border ao método .save().

import segno
qrcode = segno.make('Vampire Blues')
qrcode.save('vampire-blues.png', border=5)

Os códigos QR que criamos eram muito pequenos. Podemos fazê-los parecer maiores adicionando o parâmetro de escala como este:

import segno
qrcode = segno.make_qr('Welcome')
qrcode.save('welcome.png', scale=10)

Como criar códigos QR coloridos

Também podemos criar alguns códigos QR coloridos com o Segno – eles são realmente lindos. Isso é possível com a ajuda de muitos serializadores que aceitam os parâmetros escuro e claro para especificar a cor dos módulos escuros e claros.

Aqui estão alguns exemplos para lhe dar uma ideia do que é possível:

import segno
qrcode = segno.make("Green ave, Kingston")
qrcode.save('address.png', dark='darkred', light='lightblue', scale=10)

import segno
qrcode = segno.make("Green ave, Kingston")
# Módulos escuros com transparência alfa
qrcode.save('address2.png', dark='#0000ffcc', scale=10)

import segno
micro_qrcode = segno.make('Rain', error='q')
micro_qrcode.save('rain.png', dark='darkblue', data_dark='steelblue', scale=5)

Como salvar códigos QR em diferentes formatos

O Segno nos dá a flexibilidade de salvar nossos códigos QR gerados em diferentes formatos de arquivo, como .svg, .png, .eps e .pdf.

Veja como você faria isso:

import segno
qrcode = segno.make('Beatles')
qrcode.save('Beatles.svg')
qrcode.save('Beatles.png')
qrcode.save('Beatles.eps')

Casos de uso para códigos QR com exemplos

Como criar um código QR para compartilhamento de URL

Podemos gerar facilmente um código QR vinculado a um URL. Isso nos permite obter conteúdo on-line usando a mesma técnica com uma carga útil um pouco maior.

Vamos criar um código QR que vincule ao canal YouTube do autor deste artigo (Velcast Podcast) e depois vamos salvá-lo.

Aqui está o código para isso:

import segno

video = segno.make('https://www.youtube.com/channel/UCNhFxpk6hGt5uMCKXq0Jl8A')
video.save('Video.png', dark="yellow", light="#323524", scale=5)

O resultado:

Como criar um código QR para uma configuração Wi-Fi

Também podemos usar a biblioteca do Segno para criar um código QR para configuração de Wi-Fi. O módulo segno.helpers oferece métodos de fábrica para gerar códigos QR padrão para codificação de coordenadas geográficas, vCards e MeCards, WIFI setups e EPC QR Codes.

O nível de correção de erro "L" é utilizado na criação de códigos QR. Se possível, aplicaremos o nível de correção de erro mais alto sem alterar a versão do QR Code.

A densidade da imagem do código QR diminui com a diminuição do nível de correção de erros, o que aumenta o tamanho mínimo de impressão. Quanto mais danos ele puder suportar antes de perder sua capacidade de leitura, maior será o nível de correção de erros.

O equilíbrio ideal entre densidade e resistência para uso geral de marketing é o Nível L ou o Nível M. Em ambientes industriais, onde pode ser difícil manter um código QR limpo ou sem danos, os níveis Q e H são as melhores opções.

from segno import helpers

qrcode = helpers.make_wifi(ssid='MyWifi', password='1234567890', security='WPA')
qrcode.designator
'3-M'
qrcode.save('wifi-access.png', scale=10)

Também podemos fazer esse código deste modo:

import segno
wifi_settings = {    
    ssid='(Wifi Name)',    
    password='(Wifi Password)',    
    security='WPA',
    }
wifi = segno.helpers.make_wifi(**wifi_settings)
wifi.save("Wifi.png", dark="yellow", light="#323524", scale=8)

Podemos usar qualquer uma das duas opções para o código. Eles resultam na mesma coisa, mas representam estilos diferentes de redação e apresentação.

Casos de uso comuns do uso de códigos QR para acesso Wi-Fi incluem:

• Em vez de fornecer códigos de acesso exclusivos aos consumidores, as empresas podem usar códigos QR para oferecer acesso Wi-Fi gratuito. Os clientes precisam apenas escanear o código para ter acesso.
• As famílias podem usá-lo para conceder aos visitantes acesso à Internet em casa.

Como codificar detalhes de contatos em códigos QR

Também podemos armazenar detalhes de contato em um código QR. Basta usar o método helpers.make_mecard() e passar os dados de contato. É importante observar que podemos passar uma lista para o método.

Vejamos um exemplo:

from segno import helpers
qrcode = helpers.make_mecard(name='Shittu Olumide', email='me@example.com', phone='+123456789')
qrcode.designator
'3-L'
# Alguns parâmetros aceitam vários valores, como e-mail, telefone, url
qrcode = helpers.make_mecard(name='Shittu Olumide', 
                             email=('me@example.com', 'email@example.com'),
                             url=['http://www.example.com', 'https://example.com/~olu'])
qrcode.save('mycontact.png', scale=5)

O Segno também permite que você execute as seguintes ações:

• segno.helpers.make_geo: inicia o programa de mapeamento integrado em uma determinada latitude e longitude.
• segno.helpers.make_email: envia uma mensagem usando um tópico e corpo predefinidos. É excelente para ativar qualquer número de atividades potenciais de um servidor de e-mail, como assinar boletins informativos, registrar sua chegada em algum lugar e muito mais.
• segno.helpers.make_epc_qr: inicia um pagamento eletrônico.

Casos de uso de código QR

Agora que você aprendeu a criar códigos QR, aqui estão algumas de suas aplicações nas empresas e no nosso dia a dia:

• Pagamentos digitais.
• Compartilhamento de informações comerciais.
• Compartilhamento de informações de contato pessoal.
• Menus em código QR em restaurantes.
• Facilitação de autenticação em Wi-Fi.

E muito mais.

Conclusão

Espero que este pequeno artigo tenha aguçado seu apetite e inspirado você a empregar códigos QR em seu trabalho e projetos pessoais.

Ao desenvolver alguns códigos QR atraentes e funcionais neste artigo, testamos o módulo do Segno para o Python. Você pode ler a documentação oficial para saber mais sobre a biblioteca.

Todo mundo é diferente, mas acredito que quase todos nós gostamos de ouvir música.

Se você deseja manter uma versão local dos áudios que costuma ouvir on-line, precisará fazer o download desses arquivos. Às vezes, você também vai querer recortar uma parte desse arquivo de áudio em vez de ter o arquivo todo disponível.

Você pode desenvolver um script em Python para fazer exatamente essas coisas. Você também pode estendê-lo com funcionalidades adicionais, se desejar. Mostrarei a você como fazer isso neste tutorial.

Uma observação sobre direitos autorais

Se você já usou a Internet antes, provavelmente está ciente de que questões de direitos autorais (em inglês, copyrights) podem deixar muitas pessoas chateadas – em ambos os lados de um debate sobre como o conteúdo livre deve ser.

A própria biblioteca que usaremos teve sua parcela de problemas com direitos autorais.

Felizmente, há material livre de direitos autorais disponível para desfrutarmos e brincarmos usando nossos programas. Portanto, usaremos neste tutorial o 4º Movimento da 9ª Sinfonia de Beethoven, que é isento de royalties.

Este guia pressupõe que você também usará os métodos ensinados para baixar material livre de direitos autorais. Não use esta informação para infringir direitos autorais!

O que vamos fazer neste tutorial

Primeiro, vamos instalar a dependência básica, FFMPEG. Em seguida, instalaremos a biblioteca youtube-dl (que também funciona com o Vimeo e muitas outras plataformas) para baixar o áudio de um URL do YouTube e usá-lo no código em Python.

Em seguida, faremos o download da biblioteca pydub para cortar arquivos de áudio e implementar essa funcionalidade em nosso código.

Por fim, criaremos uma interface de usuário amigável para que possamos reutilizar esse script mais tarde sem precisar editar o código.

Tudo isso será executado dentro de uma função main() para que possamos separar funcionalidade, implementação e uso.

Como instalar o pacote do FFMPEG

Este pacote está no centro de muitos programas multimídia (e todos os de código aberto que usei até agora). Vamos precisar dele para ambas as bibliotecas do Python que instalaremos em breve.

Como instalar no Linux

Se você está em uma máquina com o Debian (tal como o Ubuntu ou o Kali), aqui está o comando para instalar o FFMPEG:

sudo apt-get install ffmpeg

Se você está usando outros tipos de distribuições, as instruções de instalação estão aqui (em inglês).

Como instalar no Windows

Primeiro, instale o Chocolatey Package Manager. As instruções de instalação estão aqui.

Depois de instalar corretamente o Chocolatey (caso ainda não o tenha), baixe o seguinte pacote a partir de uma instância administrativa do Powershell:

choco install ffmpeg

Como instalar no Mac

Caso você ainda não o tenha, instale o homebrew. Então, em um terminal, digite:

brew install ffmpeg

Como baixar programaticamente o áudio de URLs do YouTube

Antes de mais nada, baixe o pacote youtube-dl com o pip. É um dos pacotes com mais estrelas no GitHub.

pip install youtube-dl

Vamos importar este módulo e, então, declarar uma função que baixa o áudio em formato mp3 com qualidade razoável de um URL do YouTube.

import youtube_dl # client para muitos portais de multimídia

# baixa yt_url para o mesmo diretório no qual o script é executado
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)

main()

O método .download() baixará gradualmente o fluxo de áudio como um arquivo .webm. Depois de detectar que todo o arquivo está disponível, ele usará o ffmpeg para convertê-lo em um arquivo de áudio MP3. Isso significa que, se algo acontecer, digamos que a conexão com a Internet caia quando o arquivo estiver 90% baixado, ele retomará o download em 90% em vez de desde o início – bem legal.

Observe que, se você já baixou o arquivo mp3, o download será reiniciado e substituirá o arquivo.

Execute seu script do Python. O download de áudio para esta interpretação do 4º Movimento da 9ª Sinfonia de Beethoven deve ser um arquivo MP3 de aproximadamente 33 Mb com o título do vídeo disponível localmente. Provavelmente, vai ser um pouco lento, então vá fazer um chá.

Como você pode ver, é possível passar parâmetros opcionais para youtube-dl (que também estará disponível como um programa CLI independente fora do script). Um de seus recursos é baixar uma série de vídeos de um URL de lista de reprodução. Se você estiver mais interessado, pode ler a documentação deles. Vou manter o uso mais trivial ao longo deste tutorial.

Como cortar o arquivo baixado

Com o arquivo baixado, vamos cortá-lo localmente (você deve ter considerado se é possível simplesmente baixar um clipe do YouTube. Todos os métodos confiáveis que encontrei se resumem basicamente a baixar o arquivo inteiro e depois editar localmente). Para isso, usaremos a biblioteca pydub. Você pode instalá-la assim:

pip install pydub

Esta é uma biblioteca muito boa, que permite manipular completamente o áudio, reduzindo ou aumentando o volume em determinados intervalos, repetindo clipes e assim por diante. Por enquanto, estamos interessados apenas em cortar.

Para cortar nosso arquivo baixado, teremos que obter o nome do arquivo de nosso MP3 recém-baixado, converter os pontos inicial e final de nosso intervalo de áudio desejado de "horas:minutos:segundos" para milissegundos e, finalmente, usar o pydub para cortar nosso arquivo de áudio.

Como obter o nome do arquivo

Infelizmente, o método .download() não retornará nosso nome de arquivo gerado, ao qual também não teremos acesso, pois estamos apenas passando o URL como parâmetro. Temos, porém, o Python – e ele é uma ferramenta fantástica.

Sabemos que estamos procurando um arquivo .mp3 que foi gerado logo antes de nossa operação de pesquisa de nome de arquivo (por padrão, o Python executa em thread única e executará o código de forma síncrona). Pegaremos o nome do nosso MP3 mais recente no diretório do script, e esse será o nosso arquivo.

Podemos realizar esta operação listando todos os arquivos .mp3 no diretório local, coletando suas datas e horas como números inteiros (o que significa tempo em milissegundos contados a partir de uma determinada data no passado – ou seja, quanto maior o valor, mais distante no tempo o arquivo foi criado), e obtendo o arquivo com o valor mais alto.

Para isso, vamos precisar dos módulos glob para navegar no diretório e os para obter informações de data e hora, ambos disponíveis nativamente.

import glob
import os

def newest_mp3_filename():
    # lista todos os mp3s no diretório local
    list_of_mp3s = glob.glob('./*.mp3')
    # retorna o mp3 com o valor de data e hora mais alto
    return max(list_of_mp3s, key = os.path.getctime)

Como obter HH:MM:SS como milissegundos

Assim que fatiarmos nosso arquivo, o pydub esperará intervalos de tempo expressos em milissegundos. Para nós, humanos, calcular o momento exato em milissegundos toda vez que queremos cortar um vídeo seria muito chato. Então, pediremos ao computador que faça isso por nós.

Nossa entrada será uma string no formato HH:MM:SS. Isso funciona bem se quisermos cortar um vídeo com mais de uma hora, mas, na maioria das vezes, queremos apenas obter o intervalo de tempo de minuto:segundo para outro. Então, temos que levar isso em consideração também.

Um milissegundo é 1/1000 de segundo. Um minuto são 60 segundos e uma hora são 60 minutos. Portanto, temos que obter o valor para horas, depois para minutos e depois para segundos, realizar a conversão de milissegundos em cada um e depois somar as partes para chegar ao resultado.

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # se estiver no formato HH:MM:SS
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # ponto no tempo em milissegundos
    return hours + minutes + seconds

Como obter o áudio cortado

Agora, vamos ler nosso MP3 como um objeto pydub e fatiar nosso intervalo desejado. A sintaxe é exatamente a mesma das operações de fatiamento em strings e arrays, mas, em vez de um índice para um elemento, usaremos milissegundos para instantes específicos dentro do áudio.

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # levanta um erro para suspender imediatamente a execução do programa
        raise Exception("No MP3 found in local directory.")
    # lê o mp3 como um objeto PyDub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Beginning trimming process for file ", mp3_filename, ".\n")
    print("Starting from ", initial, "...")
    if (len(final) > 0):
        print("...up to ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 up to t1
    return sound[t0:] # t0 até o fim

Como juntar tudo

Alle Menschen werden Brüder,
Wo dein sanfter Flügel weilt.
-- Friedrich Schiller

Caso você esteja se perguntando, o fragmento anterior se traduz em "criais-nos um mundo irmão, insuflais nosso Canto". É um fragmento de Hino à alegria (e, inglês, Ode to Joy), um poema de Friedrich Schiller, que serve como a maior parte da letra das partes corais do 4º Movimento.

Este é o fragmento mais famoso do movimento mais famoso da mais famosa sinfonia de Beethoven. É muito provável que você reconheça esta peça, não importando sua origem ou criação.

Vamos juntar tudo o que fizemos. Faremos o download do áudio do YouTube, fatiaremos o coral de Hino à alegria (de 9:51 a 14:04) e salvaremos como <nome_do_arquivo> - TRIM.mp3.

Se você seguiu o tutorial corretamente, atualize sua função main() para executar cada etapa de modo a ficar com o MP3 completo e a versão cortada dele como arquivos disponíveis no diretório em que você executará o script. Não se esqueça de executar a função main() no final do script.

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)
    initial = "9:51"
    final = "14:04"
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # salva o arquivo com o mais novo nome de arquivo
    trimmed_file.export(trimmed_filename, format="mp3")

Como adicionar interação de usuário diretamente da interface de linha de comando

Para esta parte, precisaremos do módulo sys do Python, que lê a entrada passada pela linha de comando (entre outras coisas). Simplesmente atualizaremos as variáveis na função main() para ler a entrada da CLI em vez dos dados atualmente codificados.

O ARGV lê a entrada sequencialmente como um array, começando no índice 1 (0 representa o nome do script Python em execução). Vamos configurá-lo para ler um URL como o primeiro argumento e, em seguida, os instantes de corte inicial e final (opcional).

import sys

def main():
    if (not len(sys.argv) > 1):
        print("Please insert a multimedia-platform URL supported by youtube-dl as your first argument.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # exit if no instants as args
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # salva o arquivo com o mais novo nome de arquivo
    trimmed_file.export(trimmed_filename, format="mp3")

Execute o arquivo para testá-lo. Lembre-se de atualizar o nome do script para aquele que está em sua máquina.

python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04

Script final

Esta é a versão final, com tudo junto. Observe que os comentários sobre os módulos estão relacionados apenas ao que estamos usando e que a função main() está sendo invocada na última linha.

import youtube_dl # cliente para baixar a partir de vários portais de multimídia
import glob # operações de diretório
import os # interface para informações fornecidas pelo sistema em arquivos
import sys # interface para a linha de comando
from pydub import AudioSegment # somente operações de áudio

def newest_mp3_filename():
    # lista todos os mp3s no diretório local
    list_of_mp3s = glob.glob('./*.mp3')
    # returna mp3 com o valor de data e hora mais alto
    return max(list_of_mp3s, key = os.path.getctime)

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # se estiver no formato HH:MM:SS
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # ponto no tempo em milissegundos
    return hours + minutes + seconds

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # levanta um erro para suspender imediatamente a execução do programa
        raise Exception("No MP3 found in local directory.")
    # lê o mp3 como um objeto PyDub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Beginning trimming process for file ", mp3_filename, ".\n")
    print("Starting from ", initial, "...")
    if (len(final) > 0):
        print("...up to ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # t0 up to t1
    return sound[t0:] # t0 up to the end



# baixa yt_url para o mesmo diretório no qual o script é executado
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    if (not len(sys.argv) > 1):
        print("Please insert a multimedia-platform URL supported by youtube-dl as your first argument.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # sai se não houver os tempos como argumentos
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Process concluded successfully. Saving trimmed file as ", trimmed_filename)
    # salva o arquivo com o mais novo nome de arquivo
    trimmed_file.export(trimmed_filename, format="mp3")

# exemplo de uso:
# python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04
main()

Exercícios sugeridos

1. Detecte se a primeira entrada é um URL válido ou não. Dê uma olhada nas RegEx em Python se não souber por onde começar.
2. Detecte se a segunda e a terceira entradas estão no formato válido (horas:minutos:segundos OU minutos:segundos).
3. Adicione uma opção para renomear o arquivo MP3 diretamente da CLI. Lembre-se de que os argumentos ARGV são executados em ordem.
4. Refatore este script para interagir com sua funcionalidade usando uma GUI. Pode ser um aplicativo da web ou local, sua escolha.

Considerações finais

Espero que você se divirta com este projeto e faça bom uso dele.

Lembre-se de que ganhar a vida como artista é muito difícil, especialmente para a maioria sem apoio corporativo. Lembre-se de apoiar os artistas de cujo trabalho você gosta sempre que puder e lembre-se também de apoiar o software de código aberto.