Configurando o Snapdrop no Servidor Próprio

No artigo anterior Transferindo arquivos entre dispositivos sem fio com o Snapdrop , discutimos como utilizar o Snapdrop diretamente no servidor hospedado da plataforma. No entanto, compreendemos que, por razões de maior controle e privacidade, você pode estar se perguntando se é possível instalar e configurar o Snapdrop em seu próprio servidor. Sendo assim, o objetivo deste artigo é fornecer um guia abrangente sobre como realizar a instalação e configuração do Snapdrop em seu servidor pessoal.

Instalação e Configuração do Snapdrop

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir $HOME
$ git clone https://github.com/RobinLinus/snapdrop.git
$ cd snapdrop
$ docker-compose up -d

Aguarde subir o ambiente, após concluir, abre o browser e acesse http://IPSERVIDOR:8080

Após acessar a URL http://IPSERVIDOR:8080 em ambos os dispositivos na mesma rede, um ícone com o nome aleatório do dispositivo será exibido. Clique neste ícone para selecionar o arquivo que deseja transferir para outro dispositivo conectado ao Snapdrop. Após confirmar o recebimento, a transferência do arquivo será concluída com sucesso entre dispositivos sem fio, desta vez utilizando o seu próprio servidor.

Feito!

Transferindo arquivos entre dispositivos sem fio com o Snapdrop

O Snapdrop é uma ferramenta inovadora que simplifica a transferência de arquivos entre dispositivos, sem a necessidade de instalar qualquer aplicativo. Seja para compartilhar fotos, documentos ou músicas, o Snapdrop oferece uma solução rápida e fácil. Neste artigo, vamos explorar como utilizar essa plataforma e desfrutar da conveniência que ela oferece.

1. Acesse o Snapdrop

Para começar, abra o navegador da web em seus dispositivos. Certifique-se de que ambos estão conectados à mesma rede Wi-Fi para garantir uma transferência eficiente. Em seguida, acesse o site Snapdrop ( https://snapdrop.net/ ) em ambos os dispostivos.

2. Nomeie seus Dispositivos

Ao abrir o Snapdrop em cada dispositivo, você notará que eles são identificados por nomes únicos. Para tornar a identificação mais fácil, clique sobre o nome e atribua um apelido personalizado a cada dispositivo.

3. Inicie a Transferência

A interface do Snapdrop exibirá uma tela amigável, aguardando para iniciar a transferência. Arraste os arquivos desejados para a área indicada na tela e observe como eles são transferidos instantaneamente para o outro dispositivo. O Snapdrop suporta uma variedade de tipos de arquivo, desde imagens até documentos PDF.

4. Confirme a Recebimento

Após o envio, o destinatário será solicitado a aceitar os arquivos. Isso adiciona uma camada de segurança, garantindo que apenas os arquivos desejados sejam transferidos. Basta clicar em "Aceitar" e os arquivos serão salvos no dispositivo.

Dicas Extras:

Certifique-se de que ambos os dispositivos têm uma conexão estável com a internet.

O Snapdrop é compatível com diversos navegadores, incluindo Chrome, Firefox, Safari e Edge.

Experimente usar o Snapdrop em diferentes tipos de dispositivos, como smartphones, tablets e computadores.

Considerações finais

O Snapdrop simplifica significativamente a transferência de arquivos entre dispositivos, eliminando a necessidade de cabos ou instalação de aplicativos adicionais. Ao seguir este guia passo a passo, você estará aproveitando rapidamente a conveniência e eficiência desta ferramenta inovadora. Experimente o Snapdrop e simplifique suas experiências de compartilhamento de arquivos.

Feito!

Rust: Uma Jornada pela Linguagem de Programação de Alto Desempenho

Rust é uma linguagem de programação moderna, de baixo nível e alto desempenho, projetada para fornecer controle sobre recursos de sistema, enquanto evita muitos dos bugs comuns em sistemas de software.

Criada pela Mozilla Research, a linguagem foi anunciada ao público em 2010 e desde então tem ganhado popularidade entre desenvolvedores que buscam eficiência, segurança e concorrência.

História e Filosofia

A história do Rust remonta ao trabalho de Graydon Hoare, um engenheiro da Mozilla, que começou o projeto em 2006. A linguagem foi inicialmente concebida como um projeto pessoal de Hoare e, posteriormente, evoluiu para um projeto de código aberto apoiado pela Mozilla Foundation.

A filosofia do Rust é baseada em três pilares: segurança, velocidade e concorrência. Rust visa proporcionar um ambiente de programação onde os desenvolvedores possam escrever código que seja rápido e seguro, sem sacrificar a concorrência.

Paradigma e Foco de Atuação

Rust é uma linguagem multiparadigma, mas é fortemente influenciada pelo paradigma de programação funcional. Ela oferece suporte tanto a programação imperativa quanto à programação funcional, permitindo que os desenvolvedores escolham a abordagem mais adequada para suas necessidades.

O foco principal do Rust está na criação de sistemas seguros e eficientes. Isso é alcançado através de um sistema de tipos forte e de propriedade, que ajuda a prevenir bugs como null pointer dereferences e data races. Rust também é conhecida por seu sistema de empréstimo (borrow checker), que permite o gerenciamento seguro de memória sem a necessidade de um coletor de lixo.

Instalação do Rust no GNU/Linux (Debian) e Derivados

Usando o rustup

Para instalar o Rust no GNU/Linux (Debian) e derivados, o método recomendado é usar o rustup, um gerenciador de versões para o Rust.

Siga os passos abaixo:

Abra um terminal e digite.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Siga as instruções na tela para concluir a instalação.

Após a instalação, abra um novo terminal ou execute source $HOME/.cargo/env para atualizar o ambiente.

Instalação do Rust no Windows

No Windows, o rustup também é a maneira recomendada de instalar o Rust. Siga estes passos:

Baixe e execute o instalador do rustup disponível em https://rustup.rs/ .

Siga as instruções na tela para concluir a instalação.

Após a instalação, abra um novo prompt de comando ou reinicie para atualizar o ambiente.

Exemplo de Hello World em Rust

Agora que o Rust está instalado, vamos criar um simples programa "Hello, World!" para testar o ambiente. Abra seu editor de texto preferido e crie um novo arquivo chamado main.rs com o seguinte conteúdo:

fn main() {
println!("Hello, World!");
}

Salve o arquivo e, no terminal, navegue até o diretório onde o arquivo está localizado e execute o seguinte comando para compilar e executar o programa:

rustc main.rs

./main

Você deverá ver a saída "Hello, World!" na tela.

Considerações finais

Rust representa uma abordagem inovadora para o desenvolvimento de software de sistema, combinando segurança, desempenho e concorrência. Com uma comunidade ativa e crescente, a linguagem continua a evoluir, oferecendo aos desenvolvedores uma alternativa poderosa e moderna para a criação de software robusto e eficiente. Se você busca desafios e deseja explorar uma linguagem que redefine os padrões de programação de sistemas, Rust é certamente uma escolha empolgante.

Referências

https://www.rust-lang.org/pt-BR

Feito!

Garanta a segurança de suas imagens de contêiner: Como assinar e proteger seus deployments com Cosign

A assinatura de imagens de contêiner com Cosign é uma prática importante para garantir a integridade e a autenticidade das imagens utilizadas em ambientes de contêiner. Cosign é uma ferramenta que permite assinar e verificar imagens, tornando-as mais seguras.

Por que é importante assinar as imagens de contêiner?

A assinatura de imagens de contêiner com Cosign é importante por várias razões:

Integridade da imagem: Ao assinar uma imagem, você pode verificar se ela não foi alterada após a assinatura. Isso ajuda a garantir que a imagem que está sendo executada é a mesma que foi originalmente criada e assinada.

Autenticidade: A assinatura fornece uma maneira de garantir a origem da imagem. Você pode ter certeza de que a imagem foi criada pela entidade que possui a chave de assinatura.

Segurança: A utilização de imagens de contêiner assinadas ajuda a evitar a execução de imagens maliciosas ou não confiáveis, o que pode ser crucial em ambientes de contêiner.

Conformidade: Em ambientes onde a conformidade é importante, a assinatura de imagens pode ser um requisito para cumprir regulamentos de segurança e governança.

Segue os procedimentos para o Cosign, gerar o par de chaves pública e privada para assinatura, assinar a imagem do container.

curl -O -L "https://github.com/sigstore/cosign/releases/latest/download/cosign-linux-amd64"

mv cosign-linux-amd64 /usr/local/bin/cosign

chmod +x /usr/local/bin/cosign

cosign generate-key-pair

Crie um Dockerfile para sua aplicação

Com o Dockerfile criado, pode fazer o build da imagem, conforme segue:

docker build -t usuario/nome-imagemm:1.0 .

Verifique a imagem buildada

docker images | grep nome-imagem

Publicar a imagem no Docker Hub

docker push usuario/nome-imagem:1.0

Assinar a imagem com a chave privada

cosign sign -key cosign.key usuario/nome-imagem:1.0

Verificar a imagem com a chave pública

cosign verify -key cosign.pub usuario/nome-imagem:1.0

Considerações finais

Assinar imagens de contêiner com ferramentas como o Cosign é uma prática crucial para garantir a integridade, autenticidade e segurança das imagens que você utiliza. Especialmente em ambientes de contêiner, onde a portabilidade e a confiabilidade são essenciais, a assinatura de imagens desempenha um papel fundamental na prevenção de ameaças e na garantia de que você está executando apenas o código que deseja.

Você está disposto a assumir o controle da segurança das suas imagens de contêiner a partir de hoje?

Assinar suas imagens de contêiner não é apenas uma medida de segurança, mas também uma responsabilidade para qualquer pessoa ou organização que trabalha com contêineres. É uma camada adicional de proteção que pode evitar potenciais problemas de segurança e garantir que você esteja utilizando apenas imagens confiáveis.

Portanto, não deixe a segurança de suas imagens de contêiner ao acaso. Considere seriamente a assinatura de suas imagens a partir de hoje para fortalecer a integridade e a autenticidade de seus aplicativos em ambientes de contêiner. Afinal, a segurança é um compromisso contínuo e a prevenção é sempre mais eficaz do que a correção.

Feito!

Alterando o diretório padrão do Docker

O Docker é uma das ferramentas mais populares para o empacotamento e execução de aplicativos em contêineres. No entanto, o diretório padrão de armazenamento do Docker no GNU/Linux Debian e derivados é /var/lib/docker, o que pode se tornar um problema se você estiver com espaço em disco limitado na partição raiz. Felizmente, é possível alterar o local de armazenamento padrão do Docker para outro diretório. Esse é objetivo deste post.

Por que Mudar o Diretório Padrão do Docker?

Motivo #1: Falta de Espaço na Partição Raiz

Um dos principais motivos para alterar o diretório padrão do Docker é a falta de espaço na partição raiz do sistema. O diretório padrão, que normalmente é /var/lib/docker, pode crescer significativamente à medida que você cria e executa contêineres, armazena imagens e realiza outras operações relacionadas ao Docker. Se o espaço na partição raiz se esgotar, isso pode levar a problemas de funcionamento do sistema e até mesmo à interrupção de serviços essenciais.

Ao mover o diretório de armazenamento para outra partição ou disco com espaço suficiente, você evita a falta de espaço na partição raiz e garante que o Docker continue funcionando sem problemas.

Aplicar na prática

Segue os procedimentos de configuração para alterar o diretório padrão do Docker

O Docker utiliza um arquivo de configuração chamado daemon.json para definir várias configurações, incluindo o local de armazenamento padrão. Se esse arquivo não existir, você pode criá-lo.

Para editar o arquivo de configuração, você pode usar um editor de texto de sua preferência. No exemplo a seguir, usaremos o editor vim:

sudo vim /etc/docker/daemon.json

Dentro do arquivo daemon.json, adicione a seguinte configuração para especificar o novo diretório que você deseja usar:

{
"data-root": "/caminho/para/o/novo/diretorio"
}

Certifique-se de substituir /caminho/para/o/novo/diretorio pelo caminho absoluto do novo diretório que você deseja utilizar para armazenar os contêineres e imagens do Docker.

ESC +:x (salvar e sair do editor Vim)

Antes de reiniciar o serviço Docker, é uma boa prática copiar os dados existentes do diretório padrão /var/lib/docker para o novo diretório que você especificou em data-root. Isso garante que você não perca nenhum contêiner, imagem ou dados importantes. Use o comando rsync para realizar a cópia:

sudo rsync -aP /var/lib/docker/ /caminho/para/o/novo/diretorio

Certifique-se de substituir /caminho/para/o/novo/diretorio pelo caminho absoluto do novo diretório que você definiu anteriormente.

Após copiar os dados existentes, você pode reiniciar o serviço Docker para que as alterações entrem em vigor:

sudo systemctl restart docker

Com essas etapas, você pode personalizar o local de armazenamento do Docker no Debian e desfrutar de maior flexibilidade no gerenciamento de recursos de disco em seu sistema.

Antes de concluir o processo, é essencial verificar se a alteração do diretório padrão do Docker foi bem-sucedida. Execute o seguinte comando para confirmar a configuração atual:

docker info | grep -i "Docker Root Dir:"

O resultado deve mostrar o novo diretório que você configurou em data-root. Certifique-se de que a saída corresponda ao caminho do novo diretório.

Feito!

Desvendando a Promise do JavaScript moderno

No mundo do desenvolvimento JavaScript, a programação assíncrona é uma parte fundamental. Afinal, muitas tarefas, como fazer solicitações à web, carregar recursos externos ou executar operações de longa duração, não podem bloquear a execução do código. Aqui é onde a Promise entram em cena.

O Problema da Assincronia

JavaScript é uma linguagem single-threaded, o que significa que ele executa um bloco de código após o outro. Quando nos deparamos com operações assíncronas, como buscar dados de um servidor ou ler um arquivo, não podemos simplesmente esperar que a operação seja concluída, pois isso bloquearia a interface do usuário. Em vez disso, precisamos de uma maneira de lidar com essas tarefas de forma assíncrona.

O que são Promise?

As Promises são um recurso JavaScript que nos permitem lidar com operações assíncronas de uma maneira mais organizada e eficiente. Elas representam um valor que pode não estar disponível imediatamente, mas será resolvido em algum momento no futuro. Uma Promise pode estar em um dos três estados: pendente (pending), cumprida (fulfilled) ou rejeitada (rejected).

Pendente (Pending): Este é o estado inicial de uma Promise. Isso significa que a operação ainda não foi concluída, mas pode estar em progresso.

Cumprida (Fulfilled): Isso significa que a operação assíncrona foi concluída com sucesso e a Promise tem um valor resultante.

Rejeitada (Rejected): Isso significa que ocorreu um erro durante a operação assíncrona e a Promise possui um motivo de rejeição, geralmente uma exceção ou uma mensagem de erro.

Criando uma Promise

Você pode criar uma Promise usando o construtor Promise. O construtor Promise recebe uma função executora como argumento, que possui dois parâmetros: resolve e reject. A função executora deve conter a lógica da operação assíncrona.

const exemploPromise = new Promise((resolve, reject) => {
// Realize alguma operação assíncrona aqui
// Se a operação for bem-sucedida, chame resolve com o valor desejado
// Se ocorrer um erro, chame reject com o motivo da rejeição
});

Tratando Promise

Para lidar com Promise, você pode encadear os métodos then e catch. O método then é chamado quando a Promessa é cumprida, e você pode acessar o valor resolvido. O método catch é chamado quando a Promise é rejeitada e permite que você trate erros.

exemploPromise
.then(valor => {
console.log('Operação concluída com sucesso:', valor);
})
.catch(erro => {
console.error('Ocorreu um erro:', erro);
});


Exemplo prático

Vamos ao um exemplo prático. Suponha que você deseja buscar dados de um servidor com uma Promise:

const fetchDados = () => {
return new Promise((resolve, reject) => {
// Simulando uma solicitação à API
setTimeout(() => {
const dados = { id: 1, nome: "Exemplo de Dados" };
resolve(dados);
}, 2000);
});
};

fetchDados()
.then(dados => {
console.log('Dados obtidos com sucesso:', dados);
})
.catch(erro => {
console.error('Erro ao buscar dados:', erro);
});


Neste exemplo, fetchDados retorna uma Promise que é resolvida após um atraso de 2 segundos. Se a operação for bem-sucedida, a Promise é cumprida e os dados são exibidos no bloco then. Caso ocorra um erro, a Promise é rejeitada e o bloco catch trata o erro.

As Promises são uma parte essencial do JavaScript moderno, facilitando a lida com operações assíncronas e simplificando o código. Elas são a base para muitas APIs modernas, como a API Fetch, que usa Promessas para gerenciar solicitações de rede. Aprofundar seu conhecimento em Promessas é uma habilidade valiosa para qualquer desenvolvedor JavaScript.

Feito!

Entendendo as diferenças entre Fetch e Axios

Quando se trata de fazer requisições HTTP em JavaScript, duas das opções mais populares são o método fetch e a biblioteca Axios. Ambos são utilizados para fazer solicitações a servidores web, mas eles têm diferenças significativas em termos de facilidade de uso, funcionalidade e suporte a recursos avançados. O presente post explica as diferenças entre fetch e Axios e apresenta um exemplo prático de como usar cada um deles.

fetch - O Nativo do Navegador

O fetch é um método nativo do JavaScript que permite fazer requisições HTTP. Ele foi introduzido com o objetivo de simplificar as solicitações assíncronas, permitindo que você faça requisições e receba respostas de servidores web. O fetch é amplamente suportado nos navegadores modernos e é uma parte do padrão ECMAScript.

Vantagens do fetch:

Padrão do navegador: Como parte do JavaScript nativo, o fetch está disponível em todos os navegadores modernos sem a necessidade de bibliotecas externas.

Promese: O fetch utiliza Promise, o que torna mais fácil o tratamento de respostas assíncronas.

API de Streams: Permite a leitura de respostas de maneira incremental usando a API de Streams, o que é útil para lidar com downloads de arquivos grandes.

Desvantagens do fetch:

Complexidade: O fetch pode ser mais verboso e requer manipulação manual de cabeçalhos e parâmetros.

Compatibilidade com Navegadores Antigos: Não é adequado para navegadores mais antigos, exigindo polifilas em alguns casos.

Axios - A Alternativa Popular

Axios é uma biblioteca JavaScript que simplifica a realização de requisições HTTP em comparação com o fetch. Ela é amplamente utilizada e fornece uma camada de abstração sobre o XMLHttpRequest nativo do navegador.

Vantagens do Axios:

Sintaxe Limpa: O Axios oferece uma sintaxe clara e simples para fazer solicitações HTTP, o que a torna mais amigável e fácil de usar.

Interceptores: Permite o uso de interceptores para pré-processar solicitações e respostas, o que é útil para autenticação e tratamento de erros.

Compatibilidade com Navegadores: Funciona em uma ampla variedade de navegadores, incluindo versões mais antigas, sem a necessidade de polifilas.

Desvantagens do Axios:

Dependência Externa: Você precisa incluir a biblioteca Axios em seu projeto, o que aumenta o tamanho do código em comparação com o fetch nativo.

Exemplo prático de utilização com fetch e Axios para fazer uma solitação GET a uma API REST que fornece informações do filósofo contemporâneo do século XXI.

API retorna pérolas ditas por Kanye West

Usando fetch:

  fetch('https://api.kanye.rest')
     .then(response => response.json())
         .then(data => console.log(data))
     .catch(error => console.error('Erro:', error));

Usando Axios:

npm install axios

  axios.get('https://api.kanye.rest')
    .then(response => console.log(response.data))
    .catch(error => console.error('Erro:', error));

Neste exemplo, o Axios fornece uma sintaxe mais limpa e legível em comparação com o fetch. No entanto, o fetch pode ser preferível se você estiver trabalhando em um ambiente moderno e quiser evitar dependências adicionais.

Em resumo, a escolha entre fetch e Axios depende das necessidades do seu projeto. Se você está desenvolvendo para navegadores modernos e deseja usar recursos nativos sempre que possível, o fetch pode ser a escolha certa. Por outro lado, se você procura facilidade de uso e funcionalidades adicionais, o Axios é uma opção sólida e amplamente adotada.

Ambos têm seu lugar no desenvolvimento web, e a escolha depende das circunstâncias específicas de seu projeto e de suas preferências pessoais.

Feito!