Results for tag "sql-server"

29 Articles

Desempenho do Processador x Desempenho do SQL Server – Parte 1

0 Comments
Rodrigo Ribeiro Gomes
Post /1. Este post é parte da série: Desempenho do Processador x Desempenho do SQL Server

A CPU é um dos recursos mais fundamentais, senão o mais fundamental, de um computador. É ali que todos os recursos de um computador são coordenados.  Este é o primeiro post de mais uma série onde vamos aprender conceitos básicos sobre velocidade de CPU e como podemos usar isso para análises simples em consultas de um SQL Server.

Hoje vamos obter um conhecimetno fundamental sobre CPU antes de partir para o SQL Server!

Clocks e Hertzs

Você já deve estar cansado de ver os termos “2.5 Ghz”, “3.0 Ghz”, etc. Mas você sabe de fato, o que eles significam? Embora eu necessite de uma série exclusiva somente para este assunto, é necessário um simples entendimento:

  • Quanto maior este valor, mais rápido as instruções são executadas

Basicamente,  toda CPU tem um “clock“, que é um dispositivo que “liga” e “desliga”  X vezes por segundo.  Cada vez que esse dispositivo “liga”, nós dizemos que houve um “clock tick”, ou, apenas “tick”.  Esse é o valor que você vê nas especificações:

  • Um processador de 1 Hertz (1 Hz) significa que seu clock liga e delisga 1 vez por segundo (1 tick por segundo)
  • 1000 Hertz, são 1000 ticks por segundo. Aqui se pode aplicar as unidades do SI (Sistema Internacional de Medidas) : 1000 Hertzs = 1 Khz (Kilo hertz)
  • 1 milhão de Hertzs, ou 1 MHz, significa 1 milhão de ticks por segundo.
  • 2.5 GHz (Giga Hertzs) , significa 2.5 x  1 bilhão (Giga), que equivale a 2 bilhões e 500 milhões de vezes por segundo

Uma vez que a velocidade do processador dita quantos ticks temos em um segundo, então, podemos calcular quanto tempo dura um tick. Pode parecer confuso o que eu vou dizer agora, mas é apenas uma questão de lógica, pare e reflita.

Cada tick do clock, leva um tempo fixo. Nenhum tick leva mais ou menos tempo que o outro tick. Então, quanto mais lento o processador,  maior será o tempo de 1 tick.  Pense em números pequenos, que vai ajudar:

  • Em um processador de 2 Hertzs (dois ticks por segundo), cada tick leva 500 ms (o.5 segundos)
  • Em um processador de 4 Hertz (quatro ticks por segundo), cada tick leva 250 ms ( 0.250 segundos)
  • Percebeu a fórmula mágica pra calcular o tempo de 1 tick?
    • Tempo de um Tick, em Milssegundos = 1000ms/<Número Hertzs>
    • 2.5 Mhz = 1000/2500000 = 0,0004 ms (1 tick = 400 nanossegundos)
    • 1.0 Mhz = 1000/1000000 = 0,001 (1 tick = 1000 nanossegundos)
    • 2.5 Ghz  resulta num tick muuuuuuuuuuuuuuuuuuito pequeno! faça as contas você mesmo!

 

As instruções que um processador pode executar, gastam N ticks (isso porque, grosseiramente falando, cada vez que o clock liga, ele aciona certos circuitos e sincroniza o processador com a placa mãe, etc.) . Isso vai depender de cada processador, e de cada instrução.  A velocidade da CPU dita o tempo de cada instrução:

Em uma cpu fictícia de 2 Hz, uma instrução que gastasse 1 tick, demoraria 500 ms para executar. Uma instrução de que custasse dois ticks, levaria 1 segundo. E assim por diante…

 

Porque saber de tudo isso é importante?

Quando você traz esses conceitos para o sistema operacional, e para os seus programas, como o SQL server, fica fácil entender certas coisas. No caso de uma simples consulta SQL, você tem centenas de milhares instruções executando.  Por exemplo, uma query como esta:

Pode causar a execução de milhares de instruções. Vai depender da quantidade de registros, tamanho, concorrência, etc. A questão é que, no final das contas, tudo se resumem ao que  a CPU irá fazer, e entender a velocidade do seu processador vai te ajudar a compreender certos “fenômenos” e até planejar melhor seu ambiente. Imagine como esta query seria afetada se o tempo de cada instrução dobrasse…

No próximo  post vou mostrar todos estes conceito na prática quando você executa uma query no SQL Server!

Até lá!

 

Conhecendo o Processo do SQL Server no Windows e Linux – Parte 3

0 Comments
Rodrigo Ribeiro Gomes
Post 3/3. Este post é parte da série: Conhecendo o Processo do SQL Server

Olá! Este é mais um post da série de post sobre o processo do SQL Server no Windows e Linux.

Nas duas primeiras partes, mostramos alguns conceitos importantes, como por exemplo, o que é um processo e o que é um thread. Você também aprendeu algumas ferramentas muito úteis para monitorar e obter mais informações de processos no Windows. Ainda, mostramos como podemos aplicar todos esses conceitos para obter informações úteis sobre uma instância SQL Server, como o usuário que está executando, privilégios, etc.

Hoje vamos focar tudo o que vimos e aprendemos, no Linux. O SQL Server no Linux é mais que uma realidade, então, nada mais justo do que aprender todos estes conceitos e ferramentas, também neste ambiente. O post assume que o leitor já possui uma experiência básica com Linux, conseguindo abrir um terminal ou uma sessão ssh, e digitar comandos. Se você não possui esta experiência, mas possui alguma experiência com powershell, você não terá dificuldades em compreender os exemplos.

O “Gerenciador de Tarefas”

A esta altura, você já percebeu o  Gerenciador de Tarefas do Windows é, na verdade, um “Gerenciador de Processos”. Ele te dá uma lista contendo cada processo que existe no Windows com diversas informações sobre cada um deles. Há o “process explorer” e o “Get-Process”, do powershell, também. No Linux, assim como no Windows, possuímos diversas ferramentas que nos fornecem as mesmas informações, umas com mais detalhes, outras com menos.

Por exemplo, você pode usar o comando “ps” para encontrar a linha de comando usada para iniciar o SQL Server:

Note que há dois processos. São duas instâncias? Não. No Linux, o sql server inicia um processo conhecido como “watchdog”,e este por sua vez é quem inicia um segundo processo que irá atuar como uma instância SQL como a conhecemos. Como pode notar, ambos usam o mesmo executável.  O primeiro processo fica monitorando o segundo, e em caso de falhas, irá gerar os dumps para análise. No Windows, é um recurso nativo do sistema operacional quem faz esse trabalho. Este artigo do Bob Dorr, detalha.

Você pode usar o seguinte comando para exibir o PID do processo, o usuário e a linha de comando usada:

Um exemplo:

No exemplo acima, o processo 25526 foi iniciado pelo processo 1 (PPID  = parent pid, ou, pid pai). O processo 1 (init) é semelhante ao processo System e wininit.exe do Windows, que são os responsáveis por iniciar os serviços. Então, podemos dizer que o processo 25526  é o “watchdog”, pois ele foi o primeiro processo com o executável do SQL Sever a ser iniciado. A linha seguinte, demonstra que o respectivo processo, de PID 25531, é filho de 25526 (o  watchdog), então, este é a instância SQL (é este processo, por exemplo, quem escuta na porta 1433, e processa os comandos SQL que chegam).

O comando “htop” pode ser uma alternativa interessante ao comando “ps”. Usando a tecla F5, você consegue trocar a exibição entre uma árvore de processos e uma lista ordenada:

Aqui, a coluna “PID” é auto explicativa. Ela contém o PID do processo, conceito que você já aprendeu no post anterior. É a mesma coisa. A coluna “User” informa qual o usuário sob o qual o processo está executando. A mesma informação está disponível tanto no Gerenciador de Tarefas e no Process Explorer. No powershell é necessário um script mais elaborado para obtê-la.

No Windows, você consegue ver essa relação de processo pai e processo filho melhor com o Process Explorer. Aqui está um exemplo no Windows:

Note que no Windows, não temos um outro processo pai chamado sqlservr.exe. O sqlservr.exe é filho de “services.exe”, pois eu o iniciei através de um serviço do Windows. Entretanto, ao executar um xp_cmdshell ‘ping www.microsoft.com’, podemos ver claramente processos filhos do SQL Server sendo criados. O Process Explorer demonstra que cmd.exe é filho de sqlservr.exe. E PING.EXE é filho de cmd.exe

 

Onde estão os argumentos? No caso do SQL Server no Linux, todos os parâmetros default vem do registro (na verdade, uma implementação parecida, para o Linux):

Assim, como no Windows, ainda é possível usar os parâmetros em linha de comando:

A primeira linha é o comando sudo. Da maneira em que foi executado na imagem, ele faz com que mudemos o usuário atual. O nome do usuário é “mssql”, criado por padrão na instalação do SQL. Na próxima linha, eu apenas inicio o executável do SQL Server, com o parâmetro “-e”, alterando o local do Error Log, semelhante como fizemos no Windows. A razão pelo qual eu mudei de usuário é apenas para evitar problemas de permissão quando eu iniciar o serviço normalmente usando o gerenciador de serviço (systemctl). Eu recomendo que não faça isso, principalmente em ambiente de produção, pois pode vir a ter seu serviço inoperável. Mas, se o fizer, e tiver problemas, tente restabelecer as permissões, desta maneira:

Aqui está o processo, usando o comando “ps”, como mostrado anteriormente:

Note que o processo é filho do processo 23892. Utilizando o comando ps, podemos observar quem é:

bash é um programa que atua como um shell no Linux, semalhante ao que o cmd, ou mesmo o powershell, é no Windows. Ele é responsável por captar e exibir a saída de comandos fornecidos no terminal. Quando eu iniciei o SQL Server na linha de comando do Linux, foi o bash da minha sessão quem o fez. Por isso, ele é o pai.

 

No Windows você também consegue iniciar o serviço do SQL Server na linha de comando. Basta mandar executar o arquivo sqlservr.exe e passar os devidos parâmetros:

Neste exemplo, eu parei o serviço do SQL, usando o Configuration Manager, e executei esta linha de comando:

Quando eu iniciei o sqlservr.exe, o usuário com o qual eu abrir o prompt é o usuário quem vai rodar esse processo. Sendo assim, todas os recursos do Sistema Operacional que minha instância precisar, estarão sujeitos a esse usuário. Note que não é o mesmo usuário que eu configurei lá “Configuration Manager”. Aquele é o usuário que será usado quando o sql for iniciado por lá (ou pelo gerenciador de serviços).

Note que, como no Linux, o processo agora é filho do “cmd.exe” (semelhante ao bash’).

No Linux, é o mesmo caso, porém, eu apenas optei por utilizar o mesmo usuário configurado nas definições do serviço. No caso do Windows, os efeitos de ser fazer isso não são tão graves como no Linux, mas ainda sim, não recomendo que faça isso em um ambiente operacional, pois poderá ter os mesmos problemas.

Como o sqlservr.exe é uma “ConsoleApplication”, ele começou a gerar a saída na tela, além do errorlog. Isso acontece nas versões para ambos os sistemas operacionais.

Bom, há muito o que falar sobre processos. Esta foi uma introdução cujo o objetivo é mostrar como ambos os sistemas operacionais fornecem a mesma visão. Porém, apesar das informações simples, elas são poderosas armas em situações de análises. As vezes, os simples fato de olhar o usuário com o qual o processo está rodando, pode te ajudar a perceber um problema devido a permissões de acesso.

Há ainda uma série de ferramentas poderosíssimas, como o Process Monitor, ou o strace, que ajudam a compreender tudo o que um processo está fazendo. Conhecer o que são os processos e seus conceitos mais simples, ajudam a melhor utilizar essas ferramentas. E em algum momento iremos dedicar atenção a elas aqui no blog!

Aqui estão algumas fontes e referências do assunto de hoje:

Conhecendo o Processo do SQL Server no Windows e Linux – Parte 2

0 Comments
Rodrigo Ribeiro Gomes
Post 2/3. Este post é parte da série: Conhecendo o Processo do SQL Server

No último post da série vimos alguns conceitos básicos sobre processos e threads, e também usamos algumas ferramentas no Windows para obter mais informações sobre o executável de um processo do SQL Server. Hoje vamos abordar mais alguns conceitos importantes e ver como podem ser úteis na prática!

O Executável do SQL Server

O executável do SQL Server é o sqlservr.exe. No Windows você o encontra em:

<ProgramFiles>\Microsoft SQL Server\<Versao>.<NomeInstancia>\MSSQL\Binn

No Linux, ele fica em:

/opt/mssql/bin/sqlservr (sem extensão).

Talvez você nunca tenha precisado interagir diretamente com o executável do SQL Server porque você sempre iniciou ele através de um serviço. Em palavras simples, um serviço está fazendo a mesma coisa que você: pedindo ao sistema operacional que inicie a execução de um arquivo. Mas, no final das contas, ele é apenas um processo. Você pode confirmar isso usando ferramentas do seu sistema operacional que permitem monitorar e gerenciar os processos, como:

Por exemplo, a seguinte imagem demonstra dois processos, cada um referente a uma instância que iniciei através do Configuration Manager:

No Gerenciador de Tarefas do Windows a partir da versão 2012/8, você encontra essas informações na aba “Detalhes” (ou “details”), Há uma linha para cada processo existente no seu sistema operacional. Se há mais de uma instância SQL Server em execução, cada instância irá ser executada em seu próprio processo. O SQL Server Agent também é outro processo, e que usa um executável diferente do SQL:

Assim como o SQL Browser, Analysis Services, etc. Cada um tem seu próprio executável, e aceitam diferentes parâmetros.

O PID

Uma das informações mais importante sobre um processo é seu identificador, ou “Process ID” (PID). O PID é um número exclusivo que um processo ganha ao ser criado no sistema operacional. Nunca existirão dois processos com o mesmo ID em uma mesma sessão do sistema operacional (isto é, depois do  boot). Porém, o ID pode ser reusado quando seu respectivo processo encerrar. Raramente você verá o serviço do SQL Server usar o mesmo ID de processo entre seus restarts. Se ocorrer, é uma bela sorte!

A linha de comando

Repare na última coluna dessa imagem:

A coluna “Linha de comando” (você consegue habilitar mais colunas usando o botão direito do mouse no cabeçalho da tabela e selecionado a opção “Selecionar colunas”) mostra o caminho do executável que foi usado para iniciar o processo. Se você olhar na definição do serviço desta instância, poderá ver a mesma informação:

  1. Abra o gerenciador de serviços do Windows (digite “services.msc” no executar ou em um shell)
  2. Procure o serviço do SQL Server ( o nome é SQL Server (<NOME INSTANCIA>))
  3. Clique com o botão direito, e vá em propridades. Você verá uma imagem semelhante a esta:

Se você selecionar o texto sob “Caminho do Executável”, poderá ver o resto das informações.

Quando o Windows é solicitado para rodar esta linha de comando, seja diretamente pelo usuário, ou através de um serviço, ele cria um novo processo e aponta a primeira thread para o executável. Além disso, após o nome do executável há os parâmetros que devem ser passados ao processo. O Windows se encarrega de disponibilizar esses valores para a primeira thread do processo, e a partir daí ela faz o que quiser com eles.

No caso do sqlservr.exe, o parâmetro “-s” indica que o valor a seguir é um nome de instância. No caso do SQL Agent, é o parâmetro “-i” quem dita essa informação. (No post anterior há uma tabelinha contendo essas informações).

O usuário

Uma outra informação bastante útil vem da coluna “Nome de usuário”. Essa coluna indica com qual conta de usuário o processo está rodando. Todo processo, e, consequentemente, suas Threads, necessitam rodar sob alguma conta de usuário (geralmente, usamos o nome “conta de serviço”, pois estamos falando de uma conta de usuário que irá rodar um serviço. Mas é tudo a mesma coisa). Essa conta é usada pelo sistema operacional para validar o acesso a recursos do sistema operacional, como os arquivos. É comum observar erros de Access Denied a um arquivo ou diretório porque esta conta não tem as devidas permissões.

Uma outra situação comum, é ter que dar direitos específicos para que o SQL Server consiga realizar determinadas operações. Por exemplo, no Windows, o famoso Instant File Initialization é permitido somente se a conta com a qual o serviço está rodando possui um privilégio chamado SeManageVolumePrivilege. Há diversas formas de verificar se o processo tem esse privilégio habilitado e uma delas é usando o Process Explorer:

  1. Abra o process explorer como Administrador e procure o processo do SQL da instância desejada
  2. Clique com o botão direito no nome do processo e vá em “Properties”
  3. Vá na aba “Security”. No final da janela aberta, você verá a lista de privilégios com as quais o processo executa (que foi herdado do usuário associado com esse processo)

  A lista vem ordenada pelo nome do privilégio. Apesar da conta possuir alguns privilégios atribuídos, o de nosso interesse não está na lista. Após adicionar o privilégio, e reiniciar o serviço do SQL Server, conseguimos vê-lo:

Além disso, há uma série de outras informações a respeito do usuário, que podemos discutir melhor em um outro post.

Hoje conhecemos mais alguns conceitos interessantes pertinentes a um processo! No próximo post, vamos aplicar tudo o que vimos no Linux, já que até agora usamos somente Windows. E não deixe de praticar o que foi aprendido hoje:

  • Utilize as várias ferramentas disponíveis e compare os usuários com os quais o processo executa
  • Experimente retirar ou adicionar permissões da conta de serviço utilizada pelo SQL Server,e observe os efeitos na execução do serviço.
  • Reinicie o serviço do SQL Server e compare os PIDs
  • Powershell:  Explore cmdlet Get-Service ou a classe WMI win32_service para obter mais informações sobre um serviço do Windows
  • Pergunta de prova: Duas instâncias, em diferentes computadores, podem compartilhar o mesmo PID?

Conhecendo o Processo do SQL Server no Windows e Linux – Parte 1

2 Comments
Rodrigo Ribeiro Gomes
Post 1/3. Este post é parte da série: Conhecendo o Processo do SQL Server

Apesar do seu enorme papel nas grandes corporações do mundo, o SQL Server, assim como todos os outros SGBDs, não é nada mais nada menos que apenas um processo do sistema operacional. Assim, conhecer os fundamentos de um processo, é essencial para ter sucesso na hora de lidar com o SQL Server.

Há uma série de informações que você pode coletar apenas usando ferramentas do sistema operacional. Sabendo manipular melhor o processo do SQL você consegue não somente ter um maior controle sobre suas instâncias, mas também ter mais cartas na manga para resolver um problema incomum, e até montar interessantes linhas de raciocínio.

Nesta série, iremos mostrar alguns conceitos e ferramentas úteis para o dia-a-dia de quem Administra instâncias SQL Server, não somente em ambiente Windows, mas em Linux, e até docker.

Processos e threads

Eu sempre digo em minhas apresentações que entender o que é uma Thread é essencial pra entender e dominar o SQL Server. Afinal, tudo se resumem a elas. 

Em simples palavras, uma Thread é sequência de instruções (isso, Assembly, nada de SQL ainda) e cada CPU pode executar uma única Thread por vez.

Um processo é uma espécie de “grupo” de Threads, grosseiramente falando. Os processos definem quais recursos suas threads tem acesso. Tais limites podem ser impostos por um usuário administrador, através de configuração, ou por características de hardware e/ou do sistema operacional.  Há uma série de informações que um processo contém.

Processos são isolados de outros processos. Isso significa que threads de um processo não conseguem acessar recursos, como memória, de outros processos da mesma maneira, que é simples, como fazem com seus próprios recursos. Você verá que isso explica muita coisa quando trabalha com múltiplas instâncias!

 

Para resumir:

  • Thread: É a coisa que, de fato, executa instruções em uma CPU. Há várias dessas coisas o tempo inteiro em um SO.
  • Processo: É como se fosse um “grupo” de threads. Um processo não executa código, mas contém, no mínimo, uma thread. Além disso, o processo contém uma série de outras informações que limitam os recursos que uma thread pode acessar.

Executável e Argumentos

Todo processo começa a partir de um arquivo binário, contendo as instruções que o processador deverá executar. No Windows, esse binário geralmente tem a extensão .exe, e no Linux sem uma extensão específica. Ele é gerado a partir de alguma linguagem de programação, como C++, que é o caso do SQL Server.

Iniciar um programa significa pedir ao sistema operacional que execute um arquivo binário como esse. Quando o sistema operacional é acionado para tal ação, ele cria um novo processo em sua lista de processos, e também cria a primeira thread desse processo e a aponta para a primeira instrução que se encontra no arquivo binário. A partir daí, a thread seguirá seu fluxo de execução, realizando as mais variadas operações que foram codificadas, como abrir arquivos, receber conexões, processar texto,  fazer cálculos e até criar novas threads.

Todo executável pode receber um ou mais parâmetros, que são strings passadas por quem o iniciou. A sintaxe é:

NomeExecutavel Parametro1 Parametro2 “Parametro 3, com espacos”

O SQL Server contém uma série de parâmetros documentados e não documentados. Quem determina quais parâmetros um executável irá receber é quem o desenvolveu. Uma correta documentação irá dizer quais os parâmetros existem, como devem ser especificados e o que eles causam na execução daquele software.

No caso do SQL server, existem diversos, e os seguintes são bem conhecidos:

Parâmetro Descrição
-e Caminho para o arquivo de error log
-l Caminho para o arquivo de log do banco master
-d Caminho para o arquivo de dados do banco master
-s Nome da instância

Você pode consultar uma lista de parâmetros que o executável do SQL Server aceita neste endereço.

Você pode observar o executável usado para iniciar um processo, e seus argumentos, usando ferramentas como Gerenciador de Tarefas ou o Process Explorer:

Executável e argumentos do processo do sql server no Gerenciador de Tarefas

 

Executável e parâmetros do processo do SQL no Process Explorer

Já com powershell, uma das maneiras, é com os seguintes comandos:

Você verá um resultado como este:

 

Por hoje é só pessoal. No próximo post, veremos mais alguns conceitos e fonte de informações úteis! Até lá

Exercícios para fixar:

  • Baixe o process explorer e tente ver os argumentos dos vários processo que existem em execução
  • Use o Gerenciador de Tarefas para observar as mesmas informações:
    • Vá na aba “Detalhes”
    • Clique com o botão direito no cabeçalho da tabela
    • Escolha “Selecionar Colunas”
    • Procure na lista e marque a opção “Linha de Comando” 
    • Aproveite e explore as outras colunas que existem
  • Abra novos programas, e observe a linha de comando executada
  • Powershell: Explore o cmdlet Get-Process e o comando Get-WmiObject Win32_Process
  • PERGUNTA DE PROVA: O que acontece quando você usa xp_cmdshell?

Um Generalista a mais no mercado?

0 Comments
Rodrigo Ribeiro Gomes

Depois de um longo tempo sem postagem no blog, estou voltando aqui com algumas novidades. O tempo tem sido crucial, e muitas mudanças aconteceram em minha carreira e vida pessoal. Com isso acabei me afastando do blog. O post hoje conta um pouco do que aconteceu e o que espero pro ano de 2019!

 

Novos conhecimentos, mesmos meios

Depois de longos anos trabalhando com plataforma Microsoft, exclusivamente SQL Server e Windows, finalmente encarei a chance de conhecer outros produtos. Não um específico, mas diversos: o problema aparecia, e tinha que resolver.  Mysql, PostgreSQL, Oracle, DB2, sqlite, etc. Em um primeiro momento, acostumar com essas novas tecnologias é difícil, e chega até ser desanimador.  O SQL Server realmente é um produto incrível, e possui muitas features que tornam o dia-a-dia de um DBA muito mais fácil, porém nada básico. Possui uma engine poderosa, capaz de suportar os mais severos workloads, oriundos das mais exigentes aplicações do planeta. Por um outro lado, existem muitas features interessantes, e que até faltam no SQL Server.

Junto com o receio de se tornar um generalista, resolvi encarar o desafio. O resultado dessa experiência, conto um pouco a seguir.

A maior mudança: Linux

Sem dúvida, o maior conhecimento adquirido foi o Linux. Apesar de passar a maior parte do tempo em uma tela preta, sem usar mouse, diferente do Windows, isso não me trouxe limitação. A princípio, parece que aquilo é realmente uma caixa preta e qualquer mensagem significa o caos. Besteira. Um ambiente robusto, cheio  de controles, lógica, configurações, desafios. Nada diferente do Windows. Apenas um jeito diferente.

Aprender a usar Linux foi um dos, senão o maior, conhecimento que adquiri depois de aprender a programar e SQL Server. Eu não escondo para os meus colegas que sou fascinado pelo “internals” do SO, e o Linux me apresentou centenas de oportunidades para aprofundar mais esse conhecimento. Há quem diga que Windows é melhor, ou que Linux é melhor, ou ainda que Debian é melhor que CentOs, e vice-versa (feliz por entender agora o que esses termos significam). A velha história das comparações… Seguramente, posso dizer que é uma tremenda perda de tempo cair nessa discussão.

Hoje sou um apaixonado por bash, e meu velho powershell. Estou mesmo satisfeito por conhecer mais Linux, e poder explorar o melhor dos dois mundos. Agora, não importa se o problema é um pinguim adoecido, ou uma janela quebrada. Estarei aqui com as melhores ferramentas para resolvê-los.

 

Uma nova gama de opções de configuração e conceitos

Tive o prazer de atuar em problemas diversos em outras tecnologias de banco. Do mais simples aos mais complexos. Um dos meus primeiros desafios nos PostgreSQL foi apenas liberar o acesso de um usuário a partir de um novo IP.  Há um arquivo de configuração que você precisa editar pra isso. Aliás, é uma abordagem interessante. Diferente do SQL, há recursos nativos em outros bancos, como o PostgreSQL e no MySQL,  em que você consegue limitar o acesso do usuário a partir de um endereço. Realmente necessário? Uma discursão interessante pra uma conversa numa mesa de bar! 😆

Acostumar-se como o SQL Server instala seus binários, me fez ficar confuso com algumas tecnologias. Porém, comparar o conceito de instância do SQL Server, com os outros SGBDs, tornou as coisas mais claras no Oracle e no DB2.  No Oracle, o procedimento de instalação, reconhecido na comunidade técnica por ser “difícil”,  vai ficando mais claro a medida que você entende os conceitos. Muita coisa são apenas padrões, que, repassando de geração em geração, se torna um “é assim que se faz, pronto e acabou”. Cheguei até o ponto de criar novas instâncias Oracle manualmente, e me admirei com o fato que com apenas copiando alguns arquivos, você sobe uma “monstruosa” nova instância…  Minha dica é: entenda os conceitos de instância em “Oracle” e DB2 e você sairá vitorioso no primeiro contato com essas plataformas!

Planos de execução e Otimização de Queries

Uma das maiores causadoras de problemas em produção, a famosa lentidão de queries, não é exclusivo do SQL Server. Há sempre uma demanda para “pega as queries mais lenta e otimiza”. Essa nova jornada me trouxe um valioso conhecimento: Aprender a ler planos de execução no PostgreSQL, MySQL, etc. Sem muitas opções gráficas, me acostumei com a leitura do plano em texto.  A complexidade do Query Optimizer (QO) do SQL server deixou o caminho mais fácil para entender compreender o MySQL, que apesar de mais simples, toma decisões eficientes e inteligentes, que poupa trabalhos dos desenvolvedores. Porém, me ajudou a entender muito mais rápido os operadores do PostgreSQL, que possui uma gama infinita, com muito mais opções para controlar as decisões de seu otimizador, entretanto, com muita coisa semelhante do QO do SQL.

Num outro cenário, precisei avaliar o porquê de um simples banco no MySQL, em um portal de internet de um importante orgão do país, estava lento. Pra quem vem do SQL, é meio complicado lidar com a falta de uma sys.dm_exec_requests, ou sp_WhoIsActive. Mas, o meio de encontrar o problema é o mesmo: descubra a query, ou as queries lentas, e quais são seus gargalos. Aliado com as ferramentas do SO, conseguimos entender o problema, onde estava a limitação, e resolvemos isso usando recursos do Linux!

Também, apareceu uma chance incrível de operar um DB2, identificar locks, criar usuários, resolver gargalos, e até gerenciar uma replicação de dados!

Manipulação de Dados

Apareceu um desafio de auxiliar um processo de Auditoria de uma importante rede internacional de supermercados. Era necessário exportar conteúdo de um banco Oracle. Não tínhamos SSIS, nem interface gráfica. O desafio era tudo via linha de comando, era o que podia. Utilizamos a versão sqlcmd do oracle, o sqlplus. Com uma gama de opções, conseguimos exportar o conteúdo com sucesso.  O reconhecimento do vice-presidente desta empresa,  fez todo o esforço de usar powershell, para gerar um script bash que executava o sqlplus, valer a pena!

A triste e velha história da recuperação

Infelizmente, apesar de tantas diferenças, um problema comum: Recuperação. “O banco deu pau e não tem backup”.  Há quem diga que saber internals dos produtos é uma perda de tempo. Talvez sim, para aqueles que possuem recursos para suprir esse tipo de problema, ou mesmo que conseguem se convencer que tudo acabou nessas situações.

Além de conhecer novas formas, ferramentas e tipos de backup/restore (e em agluns casos, apenas diferente sintaxe, para os mesmos comandos), conseguir trabalhar em casos de recuperação de bancos sem backup.  Costurando bits, analisando logs, etc. Igual sempre foi no SQL nessas situações.  Alguns produtos apresentam uma comunidade forte, e documentação boa, outros nem tanto. A comunidade SQL Server realmente é um destaque quando se trata de conhecimentos mais avançados. Mas, é sensacional o fato de você poder ollhar no código-fonte do produto, gastar algumas horinhas apenas fazendo pesquisa de funções C++, entendedo as lógicas, em meios a poucos comentários de código.

 

Novos times

Uma das maiores  novidades, e, que, com muito orgulho, anuncio, foi a de entrar para o time da Fabrício Lima Soluções em Bancos de Dados.  O meu foco é o trabalho com SQL e Azure. Um time que já é muito forte e realmente tem sido animador. Além dos casos que aparecem, temos grupos de estudo, colocamos as experiências de todos para gerar soluções ótimas. É incrível o que esses caras fazem, e não é exagero a hashtag #AlwaysTunningYourData, porque é pra isso que todo esse conhecimento serve: pra fazer com que o seu SQL Server voe, seguindo as melhores e mais eficientes práticas.

Uma oportunidade que, chegou em um momento em que eu estava me distanciando do operacional de banco de dados, na Stefanini. Tendendo para automações de ações e serviços da infraestrutura, exigência da própria Adminstração de Banco de Dados, cheguei em uma equipe de inovação. Aqui aprendi python, docker(e já entrando em kubernetes), serviços cognitivos, machine learning, etc. Uma incrível oportunidade em um momento que todo o mundo já se volta para essas tecnologias!

Realmente tenho muito orgulho dos times que faço parte hoje. Ambos se beneficam das experiências adquiridas em cada um, e me apoiam. Isso faz toda diferença e realmente estou muito empolgado para 2019!

 

Na realidade, nada novo…

Apesar dessas novidades,  a essência não mudou. Ainda continuo apaixonado por assuntos de tecnologia, e gasto horas tentando entender os porquês. Se aparece um problema, seja com python, seja com sql no linux, sql no docker, db2 em Windows, eu passo algumas horas analisando cada log, cada mensagem, juntando as peças, consultando informações, abrindo ferramentas de monitoramento e trace. Tudo está interligado. Cada conhecimento em uma tecnologia, cada forma de resolver o problema, preenche uma vasta biblioteca na minha cabeça (e no meu OneNote,  Dropbox, etc.) com tudo que preciso para resolver os problemas.

E é nisso que se tem se resumindo meu dia-a-dia. Continuo sim, atuando em bancos de dados, especialmente na infraestrutura, resolvendo diretamente casos críticos ou discutindo com uma equipe como resolver. Continuo abrindo o Process Explorer, mas agora abro htop, ps ou top também. Ainda, nos casos mais bizarros, abro o Process Monitor, mas também abro o strace agora. Mais do que nunca tenho brincando com o Windbg ( e ainda não abrir um debugger no Linux, mas estamos quase lá  :-D). Leio internals de Windows, e também já lí o incrível Kernel Development do Linux. E também frequentemente consulto o código-fonte para tirar algumas dúvidas (uma delas, foi auxiliar no entendimento do “Load Average”).

Espero trazer mais em 2019 (e nesse finalzinho de 2018 também)! Mostrar como usar ferramentas, explicar conceitos, etc. Tudo o que já vinha escrito neste blog, porém com mais gama de experiência, tecnologias e ferramentas! E então, será que eu me tornei mesmo um Generalista? Não! Ainda estou envolvido com tecnologias específicas! Mas, estou acompanhando a TI, e indo com as novidades, levando tudo que aprendi até hoje para esse mundo! E tem dado certo, muito certo!

Pra fechar, novamente, a imagem que abre esse post: reflete o que foi esses meus 9 anos na área de TI, retirado da minha palestra no SQL Saturday 811: