anúncios

terça-feira, 4 de novembro de 2025

Conectando ao MS SQL Server com autenticação do usuário do Windows (Windows Authentication) em Java

Ao trabalhar com sistemas corporativos que utilizam o Microsoft SQL Server, é comum encontrar ambientes configurados para autenticação integrada do Windows. Isso significa que o acesso ao banco de dados é feito com base nas credenciais do usuário logado no sistema operacional, dispensando o uso de nome de usuário e senha definidos diretamente no banco.

Quando desenvolvemos aplicações Java que precisam se conectar ao SQL Server usando esse tipo de autenticação, é necessário realizar uma configuração específica no driver JDBC. Caso contrário, a aplicação não conseguirá autenticar corretamente o usuário e a conexão falhará.

Por que é necessário o arquivo msql-jdbc_auth.dll?

O driver oficial do SQL Server para Java, conhecido como Microsoft JDBC Driver for MS QL Server, oferece suporte à autenticação integrada do Windows através de uma biblioteca nativa chamada msql-jdbc_auth.dll.

Essa DLL atua como uma ponte entre o Java e as APIs do Windows responsáveis pela autenticação. Sem ela, o Java não teria acesso ao contexto de segurança do sistema operacional, e a tentativa de conexão com autenticação integrada resultaria em erro.

Em resumo, o Java precisa desse componente nativo para poder "herdar" as credenciais do usuário logado e repassá-las ao SQL Server de forma segura.

Passo a passo para configurar

  1. Download o driver JDBC oficial
  2. Acesse o site oficial da Microsoft e baixe o driver JDBC mais recente.

    No momento da escrita deste artigo, a versão disponível é a 12.8.1, e o link direto de download é: https://go.microsoft.com/fwlink?linkid=2283744

  3. Descompactar o pacote
  4. Após o download, descompacte o arquivo. Dentro da pasta extraída você encontrará o driver mssql-jdbc-12.8.1.jar (ou .jre11, .jre17, conforme sua versão do Java) e também a biblioteca nativa msql-jdbc_auth-12.8.1.x64.dll.

  5. Copiar a DLL para o diretório correto
  6. Copie o arquivo msql-jdbc_auth-12.8.1.x64.dll para o diretório bin da instalação do Java.

    Exemplo de caminho no Windows:

    C:\Program Files\Java\jdk-17\bin

    Esse diretório faz parte do java.library.path, o que garante que a JVM consiga localizar a DLL durante a execução.

  7. Configurar a string de conexão
  8. A string de conexão deve informar que será usada a autenticação integrada.

    Exemplo:

    String connectionUrl = "jdbc:sqlserver://localhost:1433;"
    + "databaseName=MinhaBase;"
    + "integratedSecurity=true;";
    Connection conn = DriverManager.getConnection(connectionUrl);

    Para projetos Spring Boot, configure no arquivo application.properties:

    spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
    spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

    Caso use Quarkus, a configuração fica assim:

    quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
    quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

    Observe o parâmetro integratedSecurity=true, que é o que ativa o uso da DLL para autenticação.

  9. Executar a aplicação
  10. Com a DLL no diretório correto e o driver JDBC configurado no classpath, sua aplicação Java será capaz de se conectar ao SQL Server utilizando as credenciais do usuário do Windows atual.

Configuração para Linux com Windows Authentication

Em sistemas Linux, a autenticação integrada não funciona nativamente com a DLL, pois ela é específica do Windows.

Nesse caso, o método recomendado é usar Kerberos, o mesmo protocolo que o Active Directory utiliza para autenticação entre domínios.

Passos para configurar no Linux

  1. Instale os pacotes necessários
  2. Em distribuições baseadas em Debian/Ubuntu:

    sudo apt install krb5-user libsasl2-modules-gssapi-mit

    No Fedora:

    sudo dnf install krb5-workstation
  3. Configure o arquivo /etc/krb5.conf
  4. Adicione o domínio e o servidor KDC da sua rede corporativa.

    Exemplo:

    
    [libdefaults]
        default_realm = MINHAEMPRESA.LOCAL
        dns_lookup_kdc = true
        dns_lookup_realm = true
    
    [realms]
        MINHAEMPRESA.LOCAL = {
            kdc = dc1.minhaempresa.local
        }
    
    
  5. Obtenha um ticket Kerberos com seu usuário do domínio
  6. kinit usuario@MINHAEMPRESA.LOCAL

    Após autenticar, você pode confirmar o ticket com:

    klist
  7. Configure a conexão JDBC
  8. No application.properties (Spring Boot ou Quarkus), a URL deve indicar o uso do principal Kerberos:

    Spring

    spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
    spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

    Quarkus

    quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
    quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

    A opção authenticationScheme=JavaKerberos instrui o driver JDBC a usar o ticket obtido via kinit.

Considerações finais

Essa configuração é especialmente útil em ambientes corporativos onde a política de segurança exige Single Sign-On (SSO) e o gerenciamento centralizado de permissões. Além disso, evita o armazenamento de senhas no código-fonte ou em arquivos de configuração, o que aumenta a segurança da aplicação.

Vale lembrar que a autenticação integrada funciona apenas quando a aplicação Java está sendo executada em um ambiente Windows. Para servidores Linux, é necessário configurar o Kerberos e utilizar parâmetros adicionais no driver.

Em resumo, a presença da DLL msql-jdbc_auth é fundamental para que o Java consiga usar a autenticação nativa do Windows ao se conectar ao MS SQL Server. Com ela corretamente posicionada e o driver JDBC configurado, o processo de autenticação se torna transparente e seguro, aproveitando os recursos já disponíveis no sistema operacional.

Feito!

quinta-feira, 23 de outubro de 2025

Como resolver o erro "boot failed to start gdm.service" no Ubuntu

Se ao iniciar o Ubuntu você se deparou com a mensagem "boot failed to start gdm.service", é bem provável que o problema esteja relacionado à partição raiz (/) cheia. Quando o sistema atinge 100% de uso da partição principal, diversos serviços deixam de funcionar corretamente — entre eles, o GDM, responsável pela tela de login gráfico.

A seguir, veja como corrigir esse problema de forma segura e eficiente.

  1. Acesse o terminal virtual (TTY)
  2. Como o ambiente gráfico não está inicializando, é necessário usar o terminal virtual.

    Pressione Ctrl + Alt + F2 (ou F3, F4...) para abrir o TTY.

    Em seguida, faça o login com seu nome de usuário e senha.

  3. Verifique o uso da partição raiz
  4. Depois de acessar o terminal, digite:

    df -h

    Esse comando mostra o uso de cada partição. Verifique se a partição / (raiz) está com 100% de utilização. Se estiver, é hora de liberar espaço.

  5. Limpe o cache de pacotes APT
  6. O cache do APT pode ocupar bastante espaço, especialmente se você realiza muitas atualizações. Execute:

    sudo apt clean
    sudo apt autoremove

    Esses comandos removem pacotes e dependências que não são mais necessários.

  7. Remova versões antigas do kernel
  8. Versões antigas do kernel podem consumir vários gigabytes. Para removê-las, execute:

    sudo apt autoremove --purge

    Isso limpa completamente pacotes antigos e libera espaço de forma significativa.

  9. Limpe arquivos de log antigos
  10. Os logs do sistema também podem crescer rapidamente. Para mantê-los sob controle, use:

    sudo journalctl --vacuum-size=50M

    Esse comando limita o tamanho dos logs a 50 MB, descartando os mais antigos.

  11. Confirme se o espaço foi liberado
  12. Execute novamente:

    df -h

    Se o uso da partição diminuiu, ótimo, o problema provavelmente foi resolvido. Caso ainda esteja cheia, siga para as próximas etapas.

  13. Reinstale o ambiente gráfico (se necessário)
  14. Se mesmo após liberar espaço o erro persistir, talvez o GDM ou o pacote do ambiente gráfico tenha sido corrompido. Nesse caso, reinstale-os:

    sudo apt install --reinstall ubuntu-desktop
    sudo apt purge gdm3
    sudo apt install gdm3

    Isso garante que todos os componentes necessários para o login gráfico estejam restaurados.

  15. Reinicie o sistema
  16. Por fim, reinicie o computador:

    sudo reboot

    Após o reinício,o erro "boot failed to start gdm.service" desaparecerá e o sistema deve carregar o ambiente gráfico normalmente.

    Dica final: mantenha sempre um controle do uso de espaço em disco. Você pode usar ferramentas como o Baobab (Analisador de uso de disco) para identificar rapidamente o que está ocupando espaço e evitar que o problema volte a ocorrer.

    Feito!

segunda-feira, 6 de outubro de 2025

Cliente open source da AWS para containers

O desenvolvimento de containers está no coração da computação moderna, e a AWS deu um passo ousado ao lançar o Finch—um cliente de linha de comando open source que facilita a criação, execução e publicação de containers Linux em ambientes locais.

O que é o Finch?

Finch é uma ferramenta leve e extensível que combina componentes open source como:

  • Lima: para virtualização em macOS
  • nerdctl: uma alternativa ao Docker CLI
  • containerd: runtime de containers
  • BuildKit: para construção eficiente de imagens

Inicialmente lançado para macOS, o Finch agora oferece suporte completo para Windows e Linux, tornando-se uma solução multiplataforma para desenvolvedores que desejam trabalhar com containers de forma local e integrada.

Funcionalidades principais

  • Construção de imagens com Dockerfiles
  • Execução de containers localmente
  • Push/pull de imagens para registries
  • Gerenciamento de redes e volumes
  • Suporte a aplicações multi-container via finch compose

No Linux, o Finch interage diretamente com o kernel usando namespaces e cgroups, sem necessidade de camadas de virtualização. Já no Windows e macOS, ele utiliza WSL2 e Virtualization Framework, respectivamente.

Instalação

No Debian e derivados, segue:

1.Importe a chave GPG:

curl -fsSL https://artifact.runfinch.com/deb/GPG_KEY.pub | sudo gpg --dearmor -o /usr/share/keyrings/runfinch-finch-archive-keyring.gpg

2.Adicione o repositório APT:

Para sistemas AMD64:

echo "deb [signed-by=/usr/share/keyrings/runfinch-finch-archive-keyring.gpg arch=amd64] https://artifact.runfinch.com/deb noble main" | sudo tee /etc/apt/sources.list.d/runfinch-finch.list

3.Atualize os pacotes e instale o Finch:

sudo apt update
sudo apt install runfinch-finch


Por que a AWS criou o Finch?

Segundo a equipe da AWS, a ideia surgiu da necessidade de uma ferramenta simples e padronizada para desenvolvimento de containers em ambientes locais. Em vez de depender de soluções comerciais ou montar ferramentas fragmentadas, o Finch oferece uma experiência coesa e baseada em padrões da indústria.

Comunidade e contribuições

O Finch é licenciado sob Apache 2.0 e está aberto a contribuições. A AWS incentiva desenvolvedores a participar no repositório oficial .

Finch representa uma abordagem moderna e colaborativa para o desenvolvimento de containers. Se você busca uma alternativa leve, open source e integrada ao ecossistema da AWS, vale a pena experimentar.

Feito!

quinta-feira, 21 de agosto de 2025

14 anos de blog

O blog está completando hoje, 21 de Agosto de 2025, 14 anos!

Gostaria de agradecer a todos pelo prestígio e a paciência de ler os posts que são publicados. Espero continuar compartilhando conhecimentos no blog para nossos leitores. Continuem prestigiando e divulgando o blog Mundo da Computação Integral, assim aumentamos nossa comunidade.

quarta-feira, 20 de agosto de 2025

Manipulando arquivos gigantes com Python

Quando trabalhamos com Python no dia a dia, é comum lidarmos com arquivos CSV ou Excel relativamente pequenos. Porém, em cenários de Data Science e Big Data, não é raro recebermos um arquivo que ultrapassa a casa dos gigabytes. E aí surge o problema: carregar tudo na memória de uma só vez pode simplesmente derrubar a sua máquina.

A boa notícia é que o Python tem ferramentas que permitem processar esses arquivos de forma inteligente e incremental. Hoje, vamos falar sobre o conceito de chunks.

O que são chunks?

De forma simples, um chunk é um pedaço do arquivo.

Ao invés de ler um CSV inteiro com pandas.read_csv(), podemos instruir o Pandas a carregar n linhas por vez, processar, salvar o resultado parcial e liberar memória. Assim, conseguimos trabalhar com arquivos gigantes sem precisar de um supercomputador.

Exemplo prático

Imagine que temos um arquivo transacoes.csv com 100 milhões de linhas. Queremos somar o valor total de uma coluna chamada valor.

Solução tradicional (não funciona bem em arquivos grandes):


import pandas as pd
# Isso pode travar o computador!
df = pd.read_csv("transacoes.csv")
print("Total:", df["valor"].sum())

Se o arquivo for grande demais, sua memória RAM não vai aguentar.

Solução com chunks:


import pandas as pd
total = 0
# Lendo o arquivo em blocos de 1 milhão de linhas
for chunk in pd.read_csv("transacoes.csv", chunksize=10**6):
    total += chunk["valor"].sum()

print("Total:", total)

Nesse caso:

chunksize=10**6 significa que o Pandas vai ler 1 milhão de linhas por vez.

Cada pedaço é processado, somado e descartado da memória.

Ao final, temos o total consolidado sem sobrecarregar o sistema.

Vantagens do processamento em chunks

  • Trabalhar com arquivos enormes sem precisar expandir a RAM.
  • Possibilidade de processamento incremental (ex: salvar resultados parciais).
  • Aplicável a diversas operações: filtros, agregações, limpeza de dados, exportação em lotes.

Onde isso aparece na prática?

  • Relatórios financeiros de grandes empresas.
  • Logs de servidores com milhões de registros.
  • Bases públicas gigantes, como dados do IBGE ou Kaggle.

Considerações finais

Trabalhar com chunks é quase um rito de passagem para quem está saindo do Python intermediário e entrando em projetos de nível avançado, onde eficiência importa tanto quanto clareza do código.

Feito!

terça-feira, 19 de agosto de 2025

Automação de tarefas com Python e Pandas

Imagine o seguinte cenário: toda semana você recebe relatórios de vendas em formato CSV e precisa consolidá-los em uma única planilha para gerar um resumo.

Fazer isso manualmente pode levar horas. Mas com o Pandas, é questão de segundos.

O Pandas é uma das bibliotecas mais poderosas do ecossistema Python para análise, transformação e automação de dados.

Se você já lidou com planilhas no Excel, vai se sentir em casa, mas aqui, com muito mais poder e automação.

Preparando o ambiente

Como sempre, vamos manter nosso projeto isolado em um ambiente virtual.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o Pandas

Abre o terminal:

pip install pandas openpyxl

pandas: biblioteca principal para análise de dados.

openpyxl: permite exportar para Excel (.xlsx).

Lendo um arquivo CSV

Vamos começar simples: carregar um relatório em CSV e inspecionar os dados.

relatorio-vendas.py


import pandas as pd

# Carregar o arquivo CSV
df = pd.read_csv("vendas.csv")

# Exibir as primeiras linhas
print(df.head())

Se o arquivo vendas.csv contiver algo como:


data,produto,quantidade,valor
01/08/2025,Notebook,3,3500
01/08/2025,Mouse,10,80
01/08/2025,Teclado,5,150

A saída será uma tabela organizada, semelhante a uma planilha.

python3 relatorio-vendas.py

         data   produto  quantidade  valor
0  01/08/2025  Notebook           3   3500
1  01/08/2025     Mouse          10     80
2  01/08/2025   Teclado           5    150

Filtrando e transformando dados

Agora vamos selecionar apenas vendas acima de R$ 1000.


filtro = df[df["valor"] > 1000]
print(filtro)

Resultado:


         data        produto   quantidade  valor
0        01/08/2025  Notebook     3        3500


Exportando para Excel


filtro = df
filtro.to_excel("vendas_filtradas.xlsx", index=False)
print("Relatório exportado para vendas_filtradas.xlsx")

Com isso, temos um arquivo pronto para ser compartilhado, sem precisar abrir o Excel manualmente.

Mini-projeto: Consolidando múltiplos relatórios

Imagine que você recebe vários arquivos CSV (vendas_jan.csv, vendas_fev.csv, etc.).

Podemos juntá-los em um único relatório com poucas linhas de código:


import pandas as pd
import glob

# Carregar todos os arquivos CSV
arquivos = glob.glob("vendas_*.csv")

# Concatenar em um único DataFrame
dfs = [pd.read_csv(arq) for arq in arquivos]
df_final = pd.concat(dfs, ignore_index=True)

# Salvar no Excel
df_final.to_excel("vendas_consolidadas.xlsx", index=False)
print("Relatório consolidado gerado com sucesso!")

Agora, em vez de copiar e colar manualmente dezenas de planilhas, você automatiza tudo em segundos.

Quando usar Pandas para automação

O Pandas é ideal para:

  • Processar grandes volumes de dados de forma rápida.
  • Automatizar tarefas repetitivas de ETL (Extract, Transform, Load).
  • Transformar relatórios em insights prontos para análise.

Considerações finais

Com o Pandas, você elimina horas de trabalho repetitivo e ganha produtividade, transformando relatórios manuais em processos automáticos e confiáveis.

Feito!

segunda-feira, 18 de agosto de 2025

Criando APIs REST com Python

Imagine que você precisa criar um serviço que permita que outros sistemas ou aplicações acessem seus dados de forma segura e padronizada. É aí que entram as APIs REST, uma das formas mais comuns de comunicação entre aplicações na web.

E, quando falamos de Python,um dos frameworks leve e eficientes para construir APIs é o FastAPI.

O que é o FastAPI?

O FastAPI é um framework web para Python, projetado para criar APIs de forma:

  • Rápida:
  • otimizado para alta performance usando programação assíncrona.

  • Segura:
  • valida automaticamente os dados recebidos.

  • Produtiva:
  • gera documentação interativa automaticamente.

Ele é tão eficiente que já é usado em produção por empresas como Microsoft e Uber.

Por que usar o FastAPI?

Velocidade de desenvolvimento: você escreve menos código para fazer mais.

Validação automática: parâmetros e dados recebidos são verificados automaticamente.

Documentação integrada: acesso imediato à documentação interativa via Swagger UI e ReDoc.

Desempenho: comparável a frameworks rápidos como Node.js e Go.

Preparando o ambiente

Como nas postagens anteriores, vamos criar um ambiente virtual para manter as dependências isoladas.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o FastAPI e o servidor Uvicorn

pip install fastapi uvicorn

fastapi: framework para criar a API.

uvicorn: servidor leve e rápido para rodar a aplicação.

Criando sua primeira API

Crie um arquivo chamado main.py

Executando a aplicação

No terminal:

uvicorn main:app --reload

main:app main é o nome do arquivo, app é a instância do FastAPI.

--reload reinicia automaticamente o servidor ao modificar o código.

Acesse no browser:

http://127.0.0.1:8000/api

Rota inicial.

http://127.0.0.1:8000/docs Documentação interativa (Swagger UI).

http://127.0.0.1:8000/redoc Documentação alternativa (ReDoc).

Desafio: API de To-Do List

Você pode ampliar este exemplo para criar um CRUD (Create, Read, Update, Delete) de tarefas:

POST /tarefas cria tarefa.

GET /tarefas lista tarefas.

PUT /tarefas/{id} atualiza tarefa.

DELETE /tarefas/{id} remove tarefa.

Essa base será extremamente útil para aplicações reais.

Considerações finais

O FastAPI combina velocidade, praticidade e robustez, sendo ideal para desenvolvedores que querem criar APIs modernas sem complicação.

Referências

https://fastapi.tiangolo.com

Feito!