Category Archives: SQL

AWS, SQL, SQLServerPedia syndication, Uncategorized, Virtual PASS BR

Babelfish

Leave a comment

Conhecem aquela história da fadinha do dente? ou aquela outra que você ouviu que um amigo de uma amigo de um conhecido do irmão da tia do sobrinho já usou e é legal?

Então, prazer esse é o Babelfish, ele é feinho, tem uns problemas, parece um político (vende mais do que entrega), mas tá aqui pra te ajudar.

Mas pra que ele server?

Imagina o seguinte, por algum acaso do destino o pessoal descobriu que o licenciamento do SQL Server é caro, não da mais para ficar usando o SQL Enterprise para manter as bases da empresa, o Standard não é uma opção (porque afinal é o Std e ninguém gosta,,, brincadeira) por qualquer que seja o motivo, as vezes até birra de gerente novo que tem birra do SQL Server (não sabe usar e quer dar pitaco de DBA), corte de custos, escolhe o motivo, tanto faz, é só uma desculpa para o: ¨por que não?¨

Como DBA temos que ter a mente aberta para outras dores de cabeça, afinal nossa vida é tranquila d+ para não sofrer multi-plataforma ou multi-banco.

TEORICAMENTE esse cara deve ajudar você a conseguir ter uma transição mais suave entre o SQL Server e o Postgresql, como um intermediário para interpretar o T-SQL para o PLPGSQL em tempo de execução.

Para entender detalhadamente como o Babelfish da AWS funciona, é importante mergulhar nas camadas técnicas e de comunicação que facilitam a compatibilidade entre SQL Server e PostgreSQL. O Babelfish atua como uma ponte entre esses dois mundos, interpretando chamadas SQL Server para o formato PostgreSQL e vice-versa, permitindo que aplicativos escritos para SQL Server interajam com o Aurora PostgreSQL como se estivessem se comunicando com um banco de dados SQL Server nativo. Vamos detalhar essas camadas e o processo de comunicação.

Entendendo as Camadas do Babelfish

O Babelfish implementa duas principais camadas de funcionalidade:

  1. Camada de Protocolo de Comunicação:
    • O SQL Server utiliza o protocolo TDS (Tabular Data Stream) para a comunicação entre cliente e servidor. O Babelfish é capaz de entender e interpretar o protocolo TDS, permitindo que clientes SQL Server se conectem ao Aurora PostgreSQL como se fosse um servidor SQL Server. Essa camada de comunicação traduz as requisições TDS em chamadas SQL compreensíveis pelo PostgreSQL.
  2. Camada de Tradução de SQL:
    • Após a comunicação ser estabelecida através do TDS, as instruções SQL, procedimentos armazenados, funções, e tipos de dados específicos do SQL Server são traduzidos para seus equivalentes no PostgreSQL. Esta camada lida com a conversão de sintaxes de consulta, tipos de dados, e semânticas de execução, assegurando que as operações executadas pelos aplicativos funcionem corretamente no Aurora PostgreSQL.

Como o Babelfish Funciona na Prática

O processo de interação entre um aplicativo SQL Server e o Aurora PostgreSQL através do Babelfish envolve várias etapas:

  1. Estabelecimento de Conexão:
    • O cliente SQL Server inicia uma conexão usando o protocolo TDS, direcionada ao endpoint do Babelfish na instância Aurora PostgreSQL.
    • O Babelfish aceita a conexão TDS, estabelecendo um canal de comunicação entre o cliente e o Aurora PostgreSQL.
  2. Execução de Consultas:
    • Quando uma consulta SQL Server é enviada pelo cliente, a camada de protocolo de comunicação do Babelfish recebe a requisição em formato TDS.
    • A camada de tradução de SQL então converte a consulta do formato SQL Server para uma consulta compatível com PostgreSQL, incluindo a tradução de tipos de dados e a sintaxe de procedimentos armazenados, se necessário.
  3. Processamento de Consultas:
    • A consulta traduzida é processada pelo Aurora PostgreSQL, e os resultados são gerados.
    • Os resultados são então encapsulados em um formato compreensível pelo protocolo TDS e enviados de volta ao cliente SQL Server através do Babelfish.
  4. Retorno dos Resultados:
    • O cliente SQL Server recebe os resultados como se estivesse interagindo com um banco de dados SQL Server nativo, completando a operação.

Considerações de Implementação

  • Compatibilidade: Enquanto o Babelfish oferece uma alta grau de compatibilidade, existem limitações e diferenças que devem ser consideradas. Nem todas as funcionalidades e comportamentos do SQL Server são suportados 1:1 no PostgreSQL através do Babelfish.
  • Otimização de Desempenho: A tradução entre os dialetos SQL pode introduzir overheads de desempenho. É importante monitorar o desempenho das aplicações e ajustar as consultas ou a configuração do Babelfish conforme necessário.
  • Gerenciamento de Transações: O Babelfish suporta transações, mas as diferenças na gestão de transações entre o SQL Server e o PostgreSQL podem requerer atenção especial para garantir a integridade dos dados.

Instalando e Configurando o Babelfish Localmente

Pré-Requisitos

Antes de iniciarmos, certifique-se de que você tem os seguintes pré-requisitos em seu sistema:

  • Sistema operacional compatível (Linux/Windows)
  • PostgreSQL instalado e funcionando
  • Acesso administrativo ao sistema
  • Conhecimento básico em linha de comando e administração de banco de dados

Passo 1: Baixar o Binário do Babelfish

Inicialmente, você precisa obter o binário do Babelfish para sua plataforma. A AWS disponibiliza esses binários através do seu site oficial ou repositório GitHub. Acesse o GitHub do Babelfish para encontrar a versão mais recente compatível com seu sistema.

Passo 2: Instalação do Babelfish

Após o download, siga os passos específicos para sua plataforma para descompactar e instalar o binário. Em sistemas baseados em Linux, geralmente envolve extrair o conteúdo do arquivo e executar um script de instalação. Por exemplo:

tar -zxvf babelfish-version-linux.tar.gz cd babelfish-version ./install.sh

Passo 3: Configurando o PostgreSQL para o Babelfish

Com o Babelfish instalado, o próximo passo é configurar seu PostgreSQL para trabalhar com o Babelfish. Isso geralmente envolve editar o arquivo de configuração postgresql.conf do PostgreSQL para incluir parâmetros específicos do Babelfish, como:

# Exemplo de parâmetros a serem adicionados ao postgresql.conf listen_addresses = '*' 
babelfishpg_tsql.database_name = 'NomeDoBancoSQLServer'

Não se esqueça de reiniciar o serviço do PostgreSQL após realizar essas alterações.

Passo 4: Criando um Banco de Dados Compatível com SQL Server

Você precisará criar um banco de dados no PostgreSQL que será utilizado pelo Babelfish para emular o comportamento do SQL Server. Isso pode ser feito utilizando o psql, o terminal interativo do PostgreSQL, com comandos como:

CREATE DATABASE NomeDoBancoSQLServer;

Passo 5: Testando a Conexão

Após a configuração, é crucial testar a conexão para assegurar que tudo está funcionando como esperado. Utilize suas ferramentas SQL Server habituais para conectar-se ao banco de dados PostgreSQL configurado, usando o endereço de IP e porta onde o PostgreSQL está rodando.

Se tudo der certo, você estará dentro do SSMS rodando query T-SQL contra um banco no Postgres.

Instalando e Configurando o Babelfish na AWS

A instalação do Babelfish é realizada através da criação de uma instância do Amazon Aurora PostgreSQL que inclui a camada de compatibilidade do Babelfish. Veja os passos:

  1. Crie uma instância do Amazon Aurora PostgreSQL:
    • Acesse o console da AWS e selecione o serviço Amazon RDS.
    • Clique em “Criar banco de dados” e selecione “Amazon Aurora”.
    • Escolha a edição compatível com PostgreSQL e a versão que inclui Babelfish.
    • Configure as especificações da instância conforme necessário e proceda com a criação.
  2. Habilitar Babelfish na Instância:
    • Após a criação da instância, navegue até a seção de parâmetros e habilite o Babelfish adicionando a configuração apropriada. Isso pode exigir a criação de um novo grupo de parâmetros se você desejar customizações específicas.

Configuração do Babelfish

Após a instalação, é necessário configurar o Babelfish para aceitar conexões do SQL Server:

  1. Configurar o Endpoint do SQL Server:
    • Localize o endpoint do Babelfish na seção de conectividade da instância Aurora PostgreSQL.
    • Este endpoint é usado para conectar aplicativos SQL Server ao Babelfish.
  2. Ajuste de Parâmetros:
    • Acesse o grupo de parâmetros da instância e ajuste as configurações para otimizar a performance e compatibilidade com seus aplicativos SQL Server.

Pontos de Atenção

Ele pode parecer a solução infalível para todos os seus problemas, mas como não existe almoço de graça ele tem limitações:

  1. Versão do Postgres oficialmente suportado, na instalação local a versão até o mento é a 14.6
  2. Limitações das “traduções”, ainda que ele faça alguns milagres naquele seu código grotesco, ele tem certas limitações, da uma lida no site do Bablefish para ver o que ele consegue fazer.
  3. Consumidor de recursos, já é de se esperar que como ele vai fazer uma tradução simultânea de comandos diretamente no canal, quanto maior o poder computacional mais rápido ele vai traduzir os comandos, então vejo esse como um dos principais gargalos de adoção na tecnologia, já que hardware é dinheiro e isso pode ficar caro.
SQL, SQLPASS, SQLServerPedia syndication, TI, Virtual PASS BR

SQL na Caixinha

Leave a comment

Que o SQL pode rodar em container já não é novidade tem um tempinho.

A facilidade que isso nos trás para testar recursos, novidades, configurações, bugs, etc. ajudou demais.

Só o trabalho de subir um SO, configurar todo o SO, atualizações do SO, baixar a instalação do SQL, todo o processo de instalação, atualização, configuração já cansa só de lembrar.

Tá certo que com a vantagem na nuvem podemos subir qualquer configuração a qualquer momento, só dependendo do limite do cartão de crédito, mas com o Docker, da pra fazer basicamente a mesma coisa sem precisar de uma conta em alguma nuvem, sem ter que ficar instalando um monte de binário com um monte de biblioteca, não se preocupando se está no patch certo do SO, etc.

Basicamente com duas linhas de comando você consegue “rodar” qualquer SQL Server do 17 até o 22 em qualquer cumulative update que houve nesse meio tempo.

Para começar, instale o Docker Desktop (https://www.docker.com/get-started/);

Após alguns restarts e atualizações você deve ter ele pronto no seu PC.

Agora, no Terminal, PowerShell, CMD digite o comando abaixo:

docker pull mcr.microsoft.com/mssql/server

Espere ele carregar algumas configurações

Em seguida vem a mágica com esse segundo comando:

docker run -e "ACCEPT_EULA=Y" -e "SA_PASSWORD=yourStrong(!)Password" -p 1433:1433 -d mcr.microsoft.com/mssql/server:2022-latest

E pronto, basicamente só isso e você vai ter um SQL Server Developer Edition 2022 rodando no seu PC

Claro que tem seus detalhes, nessa configuração simples tudo o que acontece no docker fica dentro do docker, se você apagar o container todas as bases que você criou, registros, etc. serão apagadas, o backup também conta.

Por padrão ele não integra com autenticação windows.

Se você procurar nos serviços ele não aparece listado.

Basicamente para conectar é seu hostname e a porta 1433 com usuário SA e a senha digitada ali em cima.

Caso precise da lista de todas as releases que você pode subir com o Docker a lista encontra-se aqui (https://hub.docker.com/_/microsoft-mssql-server).

AWS, SQL, SQLPASS, SQLServerPedia syndication, Uncategorized, Virtual PASS BR

AWS – EC2 com SQL

Leave a comment

Caso você contrate uma AMI com SQL e precise da mídia de instalação do SQL para qualquer atividade, na unidade C:\ existe um diretório chamado “SQLServerSetup” com os binários para a instalação do SQL Server.

Isso ajuda caso precise trocar o Collation da instância, adicionar feature, reinstalar usando uma instância, adicionar uma instância, etc..

A instalação padrão vem na instância default, collation SQL_Latin1_General_CP1_CI_AS, tempdb nas configurações NNF, sem IFI, basicamente uma instalação NNF.

Aí vem outra pergunta, por que pegar uma imagem da AWS com SQL? por que não usar um RDS?

Bom, a resposta disso é mais com você do que comigo, porque tudo vai depender da necessidade.

AMI – EC2 com SQL Instalado

  • As imagens da AWS com SQL instalado vem em diversos sabores, você escolhe o tamanho da máquina e o tipo de licenciamento STD ou ENT, eles tem developer mas se optar por esse developer você vai pagar um custo pela licença de uma aplicação que pode ser baixada gratuitamente, e ai o preço desse licenciamento do STD ou ENT vai depender do tamanho da máquina que você escolher, a vantagem fica justamente na questão de licenciamento, quem recolhe e paga para a Microsoft é a AWS, você é apenas uma empresa que está usando uma imagem já pré-instalada, então sem stress quando a licenciamento;
  • Toda a administração do ambiente e com você, eles só deixam o SQL instalado e o resto é o trabalho de casa, desde restaurar o banco até todas as rotinas de manutenção.

RDS

  • Basicamente o SQL como serviço
  • você não loga na máquina, não tem nenhum acesso a estrutura onde o SQL está instalado
  • você não é SA nem faz parte da role de Sysadmin
  • você é owner dos seus bancos
  • todas as rotinas de manutenção do SO e algumas do SQL são geridas pela AWS.
  • é uma administração meio a meio

Vou tratar da comparação entre uma AMI e um RDS em outro post.

AWS, Redshift, Scripts, SQL, SQLServerPedia syndication, TI

AWS – Redshift – Tráfego de dados

Leave a comment

Imagine o seguinte cenário:

  • Você usa o Redshift como DW ou DL para seus relatório e cargas de dados;
  • Vê uma possibilidade de facilitar sua vida e dar liberdade para o próprio cliente acessar esses dados e gerar relatórios da forma que ele achar mais legal com a ferramenta que ele quiser, etc.;
  • Mas lembra que a AWS cobra pela saída de dados;
  • Procura no portal da AWS e descobre que eles não tem uma monitoração específica de quem está saindo com dados, mas eles acertam a cobrança… incrível…
  • Mas você não quer abandonar a ideia e quer ganhar alguma grana com isso..

O que vou mostrar não é a solução perfeita, ela carece de algumas melhorias mas já é um norte para ajudar nessa ideia…

O Redshift é um PostgreSQL modificado, então muita query em tabelas de sistema do PG funciona direitinho no Redshift…

Para esse cenário, você pode criar um pacote de integration services e rodar a query abaixo contra o Redshift:

select
	TRIM(q.DATABASE) AS DB,
	TRIM(u.usename) as usename,
	sum(bytes)/1024 as kbytes,
	sum(packets) as packets,
	date(b.starttime) as data
from
	stl_bcast b
join stl_query q ON
	b.query = q.query
	AND b.userid = q.userid
join pg_user u
on u.usesysid = q.userid
where
	packets>0
	and b.starttime >= dateadd(day, -7, current_Date)
	and datediff(seconds, b.starttime, b.endtime)>0
	--and u.usename like 'usr%'
	--and querytxt not like 'fetch%'
group by TRIM(q.DATABASE)
,u.usename
,date(b.starttime)

Essa query vai trazer a informação do volume em kb trafegado pela query executada.

Com isso, você consegue montar um report incremental e ratear o custo da saída de dados da AWS.

É 100%?, não,,, mas pelo menos já é alguma coisa já que a AWS não provê dados granularizados de quem consome a saída de dados.

novos códigos serão criados também em outro repositório:

https://github.com/bigleka

AWS, Redshift, Scripts, SQLServerPedia syndication, Virtual PASS BR

AWS – Redshift – Usuário para leituras

Leave a comment

O Redshift tem umas vantagens bem interessantes, baixo custo, RDS, baixa necessidade de manutenção.

No fundo ele é um PostgreSQL modificado para prover volume de dados e não ficar trabalhando como OLTP, ele é ótimo como estrutura para DW.

Imagine o seguinte cenário, você vende uma solução mas precisa prover um acesso do seu cliente para que ele consiga acessar uma parte dos dados diretamente na sua estrutura de banco, para ele “ter a liberdade” de cruzar esses dados, montar estruturas de relatórios, etc. da forma que ele achar mais interessante, ou até mesmo exportar esses dados para uma estrutura dele e usar da forma que achar melhor.

Certo, temos várias formas de fazer isso, todas tem seus prós e contras, mas nesse caso vou usar como exemplo justamente o título do post, vamos colocar os dados no Redshift.

Então, você tem alguma forma de extração de dados incrementais (SSIS, Pentaho, Informática, estagiário, etc.) que leva os dados do seu OLTP para o Redshift e isso funciona bem.

Agora você precisa criar a estrutura de permissões para liberar o acesso do seu cliente para essa estrutura de dados.

Uma coisa muito importante : Todos os usuários do Redshift são exclusivos do banco de dados e não da instância, Então caso o cliente tenha mais de um banco ou você queira dar permissão para mais de um banco, siga o processo quantas vezes for necessário.

— Normalmente quando os objetos são criados no Redshift ele ficam armazenados no schema public.
— Isso não é um problema, o problema começa quando é criado um schema para armazenar um outro conjunto de objetos
— para um setor da empresa, ou um outro departamento…
— Quando isso acontece, o usuário owner da carga dos objetos tem acesso a essa estrutura de dados sem problema, mas novos usuários,
— ou usuários permissonalizados não tem a permissão para os objetos ou para novos objetos nesse schema.
— O script abaixo tente a sanar um cenário em que você quer liberar o acesso de select para os objetos e novo objetos em um schema pulic
— ou personalizado sem ter que ficar dando grant toda a vez que novos objetos são criados.
— Outra opção de uso é caso você tenha um Redshift na sua empresa e venda como serviço ele como datalake para algum cliente.
— dessa forma você consegue liberar um usuário para que o cliente acesse a estrutura de dados e consiga baixar os dados.

-- Normalmente quando os objetos são criados no Redshift ele ficam armazenados no schema public.
-- Isso não é um problema, o problema começa quando é criado um schema para armazenar um outro conjunto de objetos
-- para um setor da empresa, ou um outro departamento...
-- Quando isso acontece, o usuário owner da carga dos objetos tem acesso a essa estrutura de dados sem problema, mas novos usuários,
-- ou usuários permissonalizados não tem a permissão para os objetos ou para novos objetos nesse schema.
-- O script abaixo tente a sanar um cenário em que você quer liberar o acesso de select para os objetos e novo objetos em um schema pulic
-- ou personalizado sem ter que ficar dando grant toda a vez que novos objetos são criados.
-- Outra opção de uso é caso você tenha um Redshift na sua empresa e venda como serviço ele como datalake para algum cliente.
-- dessa forma você consegue liberar um usuário para que o cliente acesse a estrutura de dados e consiga baixar os dados.

-- criar um usuário
create user <username> with password ‘<password>’;

-- cria um grupo para receber as permissões
create group data_viewers;

-- adiciona o usuário ao grupo
alter group data_viewers add user <username>;

-- nesse caso remove a opção de criar objetos para os usuários do grupo
revoke create on schema public from group data_viewers;

-- atribui acesso no schema public ao grupo
grant usage on schema public to group data_viewers;

-- atribui select em todas as tabelas do schema public para o grupo
grant select on all tables in schema public to group data_viewers;

-- atribui acesso a futuros objetos do schema public para o grupo
alter default privileges in schema public grant select on tables to group data_viewers

novos códigos serão criados também em outro repositório:

https://github.com/bigleka

Powershell, Scripts, SQL, SQLPASS, SQLServerPedia syndication, TI, Virtual PASS BR, Windows

Telegram, Bot e PowerShell, uma máquina de alerta

Leave a comment

Como DBA´s estamos sujeitos a jobs, alertas, sistemas, coisas do além, gerentes, desenvolvedores, intervenções místicas, etc. executando ações no banco de dados.

Não da pra ficar olhando de perto o ambiente a todo o momento analisando cada ação, monitorando tudo o que ocorre, se preparando para o pior.

Sendo um bom DBA, você deve ter um monte de Jobs, Alertas, Operadores, Sistemas de Monitoração, aquele estagiário sendo escalpelado, entre outras formas de monitorar seus bancos, a ideia aqui é trazer mais uma opção para atazanar sua vida monótona.

Vamos a receita do desastre,,, Para isso vamos precisar:

  1. Que você tenha uma conta no Telegram
  2. Instale o aplicativo do Telegram no seu Windows
  3. Crie um Bot
  4. Configure o Bot
  5. Crie um canal e adicione esse Bot como administrador a um canal
  6. Mande uma mensagem para esse canal para criar um ID
  7. Acesse uma URL do Telegram com a chave do BOT para pegar o ID do canal
  8. Crie uma função no Powershell
  9. Declare a variável com o nome do Bot e a chave
  10. Mande uma mensagem

Vamos começar,,,

Conta do Telegram

  • PQ está lendo essa parte? vai para a próxima,,, se não sabe fazer isso nem adianta continuar…

Instale o aplicativo do Telegram no seu Windows

  • Esse ponto é interessante, acesse o cliente web do Telegram e baixe a versão para seu SO, as configurações do Bot serão feitas através do cliente e não pelo celular ou Web

Crie um Bot

  • Com sua contra criada e app instalado, acesse essa URL https://t.me/BotFather . Ele é o Bot que cria os Bot´s
  • Para criar digite /start
  • Depois digite /newbot
  • De um nome para seu Bot
  • Agora crie um username para seu bot, ele tem que terminar com bot
  • Você vai receber uma mensagem de resposta com um textão e a parte que interessa que é o TOKEN. ANOTA ISSO!
  • Aqui vale uma dica, o Bot vai aparecer em pesquisa para qualquer pessoa que use o Telegram, mas só quem tem o token vai poder realmente usar ele.

Configure o Bot

  • Adicione uma descrição para ele, uma hora você ou alguém vai fazer manutenção e vai ter que lembrar para que ele serve
  • Usando /setdescription adicione uma descrição

Crie um canal e adicione esse Bot como administrador a um canal

  • Agora usando o cliente do SO, Web ou o app do celular, crie um canal no Telegram e deixe como privado.
  • Adicione um novo membro para esse canal, nesse caso o seu Bot, vai aparecer um alerta de que o Bot precisa ser administrador do canal e bla bla bla

Mande uma mensagem para esse canal para criar um ID

  • Só o fato de criar um canal não efetiva cria o canal, até esse momento ele não tem um ID
  • Mande uma mensagem qualquer para o canal para ele criar a estrutura com o ID

Acesse uma URL do Telegram com a chave do BOT para pegar o ID do canal

  • Após mandar a mensagem acesse a URL com o token do seu Bot
  • a URL é alguma coisa assim: https://api.telegram.org/bot<aquele token do seu Bot>/getUpdates
  • deixa escrito o nome bot, remove o < e o > e cola o token
  • deve abrir uma página com alguma coisa parecida com:
{"ok":true,"result":[{"update_id":129494597,
"message":{"message_id":3,"from":{"id":XXXXXX,"is_bot":false,"first_name":"Ricardo","last_name":"Leka"},"chat":{"id":XXXXXX,"first_name":"Ricardo","last_name":"Leka","type":"private"},"date":1614187816,"text":"/start","entities":[{"offset":0,"length":6,"type":"bot_command"}]}},{"update_id":129494598,
"message":{"message_id":4,"from":{"id":XXXXXX,"is_bot":false,"first_name":"Ricardo","last_name":"Leka","language_code":"pt-br"},"chat":{"id":XXXXXX,"first_name":"Ricardo","last_name":"Leka","type":"private"},"date":1614187832,"text":"/getchatid","entities":[{"offset":0,"length":10,"type":"bot_command"}]}},{"update_id":129494599,
"channel_post":{"message_id":2,"sender_chat":{"id":-XXXX,"title":"MC1_Notify","type":"channel"} ,"chat":{"id":-XXXX,"title":"Nome_Do_Canal","type":"channel"} ,"date":1614187878,"text":"teste"}}]}

O que interessa para nós é um desses últimos “id” que estão com um símbolo de menos na frente “id”:-XXXX

Crie uma função no Powershell

  • Agora a parte mágica, vamos usar um powershell para criar a função que vai conectar na API do Telegram e mandar a mensagem…
<#
.Synopsis
    Sends Telegram text message via Bot API
.DESCRIPTION
    Uses Telegram Bot API to send text message to specified Telegram chat. Several options can be specified to adjust message parameters.
.EXAMPLE
    $bot = "#########:xxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxx"
    $chat = "-#########"
    Send-TelegramTextMessage -BotToken $bot -ChatID $chat -Message "Hello"
.EXAMPLE
    $bot = "#########:xxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxx"
    $chat = "-#########"

    Send-TelegramTextMessage `
        -BotToken $bot `
        -ChatID $chat `
        -Message "Hello *chat* _channel_, check out this link: [TechThoughts](http://techthoughts.info/)" `
        -ParseMode Markdown `
        -Preview $false `
        -Notification $false `
        -Verbose
.PARAMETER BotToken
    Use this token to access the HTTP API
.PARAMETER ChatID
    Unique identifier for the target chat
.PARAMETER Message
    Text of the message to be sent
.PARAMETER ParseMode
    Send Markdown or HTML, if you want Telegram apps to show bold, italic, fixed-width text or inline URLs in your bot's message. Default is Markdown.
.PARAMETER Preview
    Disables link previews for links in this message. Default is $false
.PARAMETER Notification
    Sends the message silently. Users will receive a notification with no sound. Default is $false
.OUTPUTS
    System.Boolean
.NOTES
    Author: Jake Morrison - @jakemorrison - http://techthoughts.info/
    This works with PowerShell Versions 5.1, 6.0, 6.1
    For a description of the Bot API, see this page: https://core.telegram.org/bots/api
    How do I get my channel ID? Use the getidsbot https://telegram.me/getidsbot
    How do I set up a bot and get a token? Use the BotFather https://t.me/BotFather
.COMPONENT
   PoshGram - https://github.com/techthoughts2/PoshGram
.FUNCTIONALITY
    https://core.telegram.org/bots/api#sendmessage
    Parameters 					Type 				Required 	Description
    chat_id 				    Integer or String 	Yes 		Unique identifier for the target chat or username of the target channel (in the format @channelusername)
    text 						String 				Yes 		Text of the message to be sent
    parse_mode 					String 				Optional 	Send Markdown or HTML, if you want Telegram apps to show bold, italic, fixed-width text or inline URLs in your bot's message.
    disable_web_page_preview 	Boolean 			Optional 	Disables link previews for links in this message
    disable_notification 		Boolean 			Optional 	Sends the message silently. Users will receive a notification with no sound.
    reply_to_message_id 	    Integer 			Optional 	If the message is a reply, ID of the original message
#>
function Send-TelegramTextMessage {
    [CmdletBinding()]
    Param
    (
        [Parameter(Mandatory = $true,
            HelpMessage = '#########:xxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxx')]
        [ValidateNotNull()]
        [ValidateNotNullOrEmpty()]
        [string]$BotToken, #you could set a token right here if you wanted
        [Parameter(Mandatory = $true,
            HelpMessage = '-#########')]
        [ValidateNotNull()]
        [ValidateNotNullOrEmpty()]
        [string]$ChatID, #you could set a Chat ID right here if you wanted
        [Parameter(Mandatory = $true,
            HelpMessage = 'Text of the message to be sent')]
        [ValidateNotNull()]
        [ValidateNotNullOrEmpty()]
        [string]$Message,
        [Parameter(Mandatory = $false,
            HelpMessage = 'HTML vs Markdown for message formatting')]
        [ValidateSet("Markdown", "HTML")]
        [string]$ParseMode = "Markdown", #set to Markdown by default
        [Parameter(Mandatory = $false,
            HelpMessage = 'Disables link previews')]
        [bool]$Preview = $false, #set to false by default
        [Parameter(Mandatory = $false,
            HelpMessage = 'Sends the message silently')]
        [bool]$Notification = $false #set to false by default
    )
    #------------------------------------------------------------------------
    $results = $true #assume the best
    #------------------------------------------------------------------------
    $payload = @{
        "chat_id"                   = $ChatID;
        "text"                      = $Message
        "parse_mode"                = $ParseMode;
        "disable_web_page_preview"  = $Preview;
        "disable_notification"      = $Notification
    }#payload
    #------------------------------------------------------------------------
    try {
        Write-Verbose -Message "Sending message..."
        $eval = Invoke-RestMethod `
            -Uri ("https://api.telegram.org/bot{0}/sendMessage" -f $BotToken) `
            -Method Post `
            -ContentType "application/json" `
            -Body (ConvertTo-Json -Compress -InputObject $payload) `
            -ErrorAction Stop
        if (!($eval.ok -eq "True")) {
            Write-Warning -Message "Message did not send successfully"
            $results = $false
        }#if_StatusDescription
    }#try_messageSend
    catch {
        Write-Warning "An error was encountered sending the Telegram message:"
        Write-Error $_
        $results = $false
    }#catch_messageSend
    return $results
    #------------------------------------------------------------------------
}#function_Send-TelegramTextMessage

Declare a variável com o nome do Bot e a chave

  • Sendo simplista você vai precisar agora criar duas variáveis a com o nome do Token e o ID do chat
$bot = "token"
$chat = "-ID_do_chat"

Mande uma mensagem

  • Agora é só chamar a função e mandar a mensagem…
  • AAHH a máquina precisa ter acesso a internet.
  • Qualquer mensagem de erro a função vai tentar trazer a mensagem para te ajudar no troubleshooting.
$bot = "token"
$chat = "-ID_do_chat"
Send-TelegramTextMessage -BotToken $bot -ChatID $chat -Message "CASA CAIU"

Com isso agora temos um powershell que acessa uma API do Telegram e manda mensagem, junta isso em um JOB que é acionado por um alerta e vc tem o SQL ou outro sistema de monitoração mandando mensagens para seu celular.

Scripts, SQL, SQLPASS, SQLServerPedia syndication, TI, Virtual PASS BR, Windows

Liberar toda a memória do servidor

Leave a comment

Todos sabemos que o SQL é um consumidor de memória frenético, quanto mais memória disponível mais memória ele vai reservar para ele.

O que é um desenho “by default”, ele sempre fará isso afinal de contas ele precisa alocar as páginas de dados do seu banco em algum lugar.

Para resolver todos os seus problemas, existe uma forma de liberar toda a memória disponível de uma só vez do seu servidor e não é parando o serviço do SQL.

Para isso, você vai precisar o Visual Studio instalado, vamos criar um novo projeto dele…

Importante! Abra o Visual Studio como administrador !

Novo projeto de linha de comando

Escreva o nome que quiser para o app

Copie e cole o código abaixo no projeto:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class CriticalProcess
{
    [DllImport("ntdll.dll", SetLastError = true)]
    private static extern int NtSetInformationProcess(IntPtr hProcess, int processInformationClass, ref int processInformation, int processInformationLength);

    static void Main(string[] args)
    {
        int isCritical = 1;  // queremos que ele seja um processo crítico
        int BreakOnTermination = 0x1D;  // valor para BreakOnTermination (flag)

        Process.EnterDebugMode();  //acquire Debug Privileges

        // configurando o BreakOnTermination = 1 para o processo ativo
        NtSetInformationProcess(Process.GetCurrentProcess().Handle, BreakOnTermination, ref isCritical, sizeof(int));
    }
}

Se tudo ocorrer como esperado, dependendo da quantidade de memória do seu servidor isso pode demorar de alguns segundos a algumas horas.

Por mais que tenhamos criado uma aplicação de linha de comando a primeira parte do processo é bem gráfica e todos já tiveram o grande prazer de conhecer:

Ele vai gerar um DUMP de toda a memória para o arquivo de paginação e depois que a maquina reiniciar ele vai copiar esse arquivo de paginação para um arquivo chamado memory.dump

É só isso,,, execução e queda,,,

Agora falando sério: NUNCA !!!! JAMAIS !!!!! Simplesmente pegue o código de qualquer coisa que você encontra na internet e saia executando sem antes entender o que ele faz.

Esse exemplo é bem ridículo, mas imagina um script que você leu o por alto achando que vai resolver todos os seus problemas de backup, ou de fragmentação de índice e descobre que no meio tem um sp_msforeach_table com um sp_msforeach_db que trunca as tabelas, ou pior, alguém cria uma chave de criptografia e habilita TDE nas suas bases e depois força a remoção da chave,,,, a culpa é tão e somente sua! Você é o DBA é sua responsabilidade preservar os dados.

Tenha discernimento com o que você copia da internet e de onde copia essas informações.

SEMPRE LEIA e NUNCA EXECUTE DIRETAMENTE EM PRODUÇÃO !!!

Powershell, SQLServerPedia syndication, Windows

Apagar arquivos de backup duplicados

Leave a comment

Imagine o seguinte cenário:

Você tem sua rotina de backup (FULL, DIFF, LOG) que gera os arquivos de saída como por exemplo BKPFULL_BASE_XPTO_01_DE_04_20181105.bak e coisas parecidas com isso.

Sua ferramenta de backup copia esses arquivos para uma área de staging todos os dias, marcando os arquivo com o bit de arquivado, no dia seguinte você tem um step do job que procura por esses arquivos e apaga ele, afinal, já foram marcados como arquivados pelo software de backup.

Em um certo momento, alguma coisa aconteceu nessa rotina da ferramenta e ela não marcou os arquivos ou simplesmente não rodou.

Para não ficar sem espaço em disco você resolve apagar o arquivo mais antigo do backup deixando pelo menos o mais recente no disco, para um ambiente com poucas bases isso é tranquilo, imagine isso para um ambiente com algumas centenas de bases, em um final de semana prolongado, algumas bases com 3 ou 4 arquivos de backup, outras com apenas 1 arquivo.

O PowerShell abaixo faz um parse no nome do arquivo para agrupar pelo tipo do backup e o nome do banco, procura onde tem mais de uma entrada (imaginando que você separa isso por discos), remove do resultado o mais recente e apaga os mais antigos.

O script não é perfeito, ainda faltam alguns detalhes à serem melhorados, mas já é uma ajuda em casos como esse:

 


Get-ChildItem "X:\Backup\Disk02\" -file | where Name -match "._(\d{4})(\d{2})(\d{2})" | Where-Object {$_.Attributes -Eq "Normal"} | #Esse Atributo é o que o software de backup marca como retido, retire este Where-Object caso queira desconsiderar isso
select fullname, #@{N="DtFile";E={[DateTime]$_.BaseName.substring($_.BaseName.length -10).replace("_", "-")}},
@{N="FileWithoutDate";E={$_.BaseName.substring(0, $_.BaseName.length -18)}} |
group FileWithoutDate |
where Count -GE 2 |
%{ $_.Group | sort fullname,DtFile -Descending | select -skip 1} | %{Remove-Item $_.FullName -WhatIf}