Ali Razeghi - AWS's questions

Eu tenho um sistema que os usuários finais precisarão consultar, mas não há garantia de que eles sejam bem versados ​​na redação de consultas. Queríamos garantir que cada instrução SELECT terminasse com um LIMIT 100000. Eu pensei em algumas regex para fazer isso e algumas ferramentas. Parece que o Query Rewrite nativo é uma boa opção, mas precisávamos usar ProxySQL para outras coisas, então eu queria ver se alguém conhece uma maneira de forçar isso.

Parece que o padrão ou regex seria algo como: qualquer coisa que comece com select precisa ter um LIMIT na linha final seguido por um espaço e um int igual ou menor que 100000, então talvez um ponto e vírgula.

Alguém teve alguma sorte fazendo isso?

Fiz um simples get-clusterresourcee notei o ' owner group'é' available storage'. Não SQL Server (instance)para o SQL Server Network Name (instance). Quero consertar isso o mais rápido possível, mas estou tendo dificuldade em descobrir como mover apenas um grupo de proprietários.

Ou, na verdade, pelo que posso dizer, o nome da rede SQL (instância) nem deveria ser um 'nome de rede'. É uma instância. Eu acho que esta é uma linha extra que eu não preciso e devo remover isso:

SQL IP Address 1 (clsnwname... Online                        SQL Server (I1)             IP Address
SQL IP Address 1 (clsnwname2... Online                        SQL Server (I2)              IP Address
SQL Network Name (clsnwname... Online                        SQL Server (I1)             Network Name
SQL Network Name (clsnwname2... Online                        SQL Server (I2)              Network Name
SQL Network Name (I1)       Failed                        Available Storage             Network Name
SQL Server (I2)              Online                        SQL Server (I2)              SQL Server
SQL Server (I1)             Online                        SQL Server (I1)             SQL Server
SQL Server Agent (I2)        Online                        SQL Server (I2)              SQL Server Agent
SQL Server Agent (I1)       Online                        SQL Server (I1)             SQL Server Agent

Eu estava testando um novo servidor que será lançado em algum momento e notei que as atualizações do Windows não estavam instalando as atualizações do SQL. Ele afirmou que não pode atualizar porque o IP está offline.

Testei o failover repetidamente e sempre funcionou e continua a funcionar conforme mostrado na GUI sem problemas e o IP está ativo. A replicação e todas as conexões estão funcionando bem.

Eu tenho um FCI de 2 nós e uma instalação autônoma do SQL Server em um nó não FCI. Eu automatizei a configuração/instalação de FCIs, AGs e réplicas de banco de dados, o que funcionou bem até agora em todos os meus testes.

Hoje estou recebendo o erro abaixo quando executo:

USE [master]
GO
CREATE AVAILABILITY GROUP [AGName]
WITH (AUTOMATED_BACKUP_PREFERENCE = SECONDARY)
FOR 
REPLICA ON N'Node3\ReadOnly' WITH (ENDPOINT_URL = N'TCP://Node3-blah.blah.com:5022', FAILOVER_MODE = MANUAL, AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT, SESSION_TIMEOUT = 10, BACKUP_PRIORITY = 50, PRIMARY_ROLE(ALLOW_CONNECTIONS = ALL), SECONDARY_ROLE(ALLOW_CONNECTIONS = ALL)),
    N'Primary/Primary' WITH (ENDPOINT_URL = N'TCP://primary.blah.com:5022', FAILOVER_MODE = MANUAL, AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT, SESSION_TIMEOUT = 10, BACKUP_PRIORITY = 50, PRIMARY_ROLE(ALLOW_CONNECTIONS = ALL), SECONDARY_ROLE(ALLOW_CONNECTIONS = NO));
GO

Erro:

Msg 19405, Nível 16, Estado 17, Linha 3
Falha ao criar, unir ou adicionar réplica ao grupo de disponibilidade 'AGName', porque o nó 'Node3' é um possível proprietário da réplica 'Node3\ReadOnly' e 'Primary/Primary'. Se uma réplica for uma instância de cluster de failover, remova o nó sobreposto de seus possíveis proprietários e tente novamente.

O nó 3 não faz parte da FCI. Ele tem uma instalação autônoma do SQL Server e não está listado como um possível proprietário.

Se eu tentar fazer failover para o Nó 3, a FCI me informará que não é um possível proprietário.

Não tenho certeza do que causou isso. Fiz failover usando o FCI entre o nó 1 e 2 vários dias antes. Desta vez, removi o ouvinte para testar, pois era a última coisa em que estava trabalhando. Alguma ideia?

Eu poderia simplesmente desmontar o FCI e fazer com que a automação o recriasse, mas queria tentar resolver isso sem fazer isso, caso isso aconteça na produção um dia. Devemos ser capazes de remover o nó do WSFC e adicioná-lo novamente, mas não quero incomodar nossa equipe de operações, que precisa fazer isso. Iremos desmontar todo o cluster e deixá-lo construir do zero antes de liberá-lo.

Editar. Esta é a saída do nó FCI:

select * from sys.dm_os_cluster_nodes

NodeName    status  status_description  is_current_owner
---------------------------------------------------------
SQNodeL001-LA   0   up  1
SQNodeL002-LA   0   up  0
SQLNode003-LA   0   up  0

A saída do autônomo está vazia. Faz parte do WSFC, mas ainda não é FCI ou AG.

A saída do powershell nos mostra que todos os 3 podem ser nós proprietários, o que é estranho.

ClusterObject                                               OwnerNodes
-------------                                               ----------
SQL Server (Instance)                                           {SQNodeL001-LA, SQNodeL002-LA, SQNodeL003-LA}

Na GUI, ele não possui o nó 3 selecionado como proprietário preferencial. Perdão por fazer pequenas alterações e remover os nomes. O nome do primeiro nó está todo em letras minúsculas. Os outros 2 estão em maiúsculas. Parece que preciso fazer tudo isso no powershell para obter os dados precisos, ainda não automatizei essa etapa. Esse será o próximo sprint.

Editar 2 - resolvido:

Graças à consulta do PowerShell de Sean, pude ver que ele ainda está listado como proprietário no PowerShell, embora não esteja na GUI. Eu removi usando get-clusterresource "sql server (instance)" | set-clusterownernode -Owners node1 node2e funcionou. Obrigado Sean!

Eu tenho algumas tabelas grandes com cerca de 6 bilhões de linhas que eu queria otimizar. A chave agrupada é Epoch (data e hora unix, que é o número de segundos que se passaram após 1970) e ID do cliente. Esta tabela registra dados de uso por cliente por tipo de produto.

Por exemplo, se for para uma Telco, TypeID 1 é uma chamada local e o valor é quantos minutos usados ​​para esse cliente. TypeID2 é uma chamada internacional e é o valor de quantos minutos foram usados ​​naquela hora para aquele cliente. Digamos que TypeID3 seja uma tarifa com desconto especial para chamadas domésticas.

Os dados são armazenados em intervalos de 1 hora. Quero que a exibição indexada armazene o valor agregado de 24 horas, portanto, quando executarmos uma consulta para 1 dia por cliente, ela deverá procurar apenas 1 linha na exibição indexada em vez de 24 linhas na tabela base.

Esta é a tabela base:

ColRowID (bigint)
AggregateID (int)
Epoch (int)
CustomerID (int)
TypeID  (tinyint)
ErrorID (smallint)
Value (int)

Não nos importamos com Aggregate ou RowID para fins de relatório, então imagino que a visualização indexada ficará assim:

CREATE VIEW [ixvw_AggTbl]
WITH SCHEMABINDING
AS
SELECT Epoch, CustomerID, TypeID, ErrorID, SUM(Value)
FROM DBO.BaseTbl
-- GROUP BY Epoch  (what goes here?? Epoch/86400?  If I do that I have to 
-- put Epoch/86400 in the SELECT list as well)

EDITAR:

Dados básicos de amostra (deixei de fora as colunas que não precisamos neste caso, apenas assuma que as colunas de ID estão lá). Cada "TypeID" terá um valor atribuído a ele, cujo valor pode ser 0.

Por exemplo,

    Epoch / Customer ID / TypeID / Value
    /* Epoch 90,000 is day 2 1am */

90000 (1am  day 2) / 1 / 1 / 200
90000 (1am  day 2) / 1 / 2 / 100
90000 (1am  day 2) / 1 / 3 / 120

/* Customer ID 2 as well */
90000 (1am  day 2) / 2 / 1 / 100
90000 (1am  day 2) / 2 / 2 / 50
90000 (1am  day 2) / 2 / 3 / 310

... (repeat for 30,000 customers)

/* Customer ID 1 2am day 1) */
93600 (2am day 2) / 1 / 1 / 150
93600 (2am day 2) / 1 / 2 / 0
93600 (2am day 2) / 1 / 3 / 550

/* Customer ID 2 2am day 2) */
93600 / 2 / 1 / 80
93600 / 2 / 2 / 150
93600 / 2 / 3 / 300
... (repeat for 30,000 customers)

Vamos supor que todas as outras colunas VALUE sejam 0 pelo restante do dia, já que o sistema caiu e ninguém pôde usar seus telefones depois das 2h. Quero que minha exibição indexada registre a coluna de valor agregada por dia, por customerID e TypeID.

Amostra seria:

172800 (Day 3 midnight) / 1 / 1 / 350  --Cust ID 1 aggregated all type id 1 in the past 24 hours
172800 (Day 3 midnight) / 1 / 2 / 100
172800 (Day 3 midnight) / 1 / 3 / 670
172800 (Day 3 midnight) / 2 / 1 / 180  --Cust ID 2 now
172800 (Day 3 midnight) / 2 / 2 / 200
172800 (Day 3 midnight) / 2 / 3 / 610
--Repeat by adding 86400 to the epoch to gather the summary data of the rows for the previous day.

Nossa empresa contratou um engenheiro de lançamento em tempo integral para o lado do MS Windows e estávamos pensando em um processo de gerenciamento de lançamento para o MS SQL Server.

SE tivermos confiança em suas habilidades para implantar scripts do SQL Server, é comum apenas o gerente de liberação fazer isso ou é algo que os DBAs normalmente fazem? Nossa empresa está crescendo rapidamente e nossos DBA's estão um tanto sobrecarregados (surpresa, surpresa, o que mais há de novo), mas podemos contratar mais, mas isso é outro assunto.

Como vocês administram isso? Você permite que um gerente de lançamento tenha acesso ao produto para implementar as alterações? Você tira os direitos e os ativa quando precisam ser liberados? Estou pensando em dar a eles acesso a um sproc que lhes dá acesso prod por uma hora, mas registra quem o chama.

Ou estou totalmente errado e isso é algo que um DBA sempre deve gerenciar?

Qualquer pensamento seria apreciado!

Editar:

Atualização: Além disso, o que acontece quando encontramos anomalias? Por exemplo, um desenvolvedor declarou que 'essas tabelas devem corresponder a esse outro ambiente (por ambiente, quero dizer ambiente de produção do cliente, não qa/stage/etc.)'. Normalmente eles fariam uma verificação no local. Fiz uma soma de verificação e notei problemas que acabaram sendo apenas problemas de espaço em branco. Em um caso como este, nós o enviamos de volta para o gerente de liberação/pessoa de controle de qualidade para consertar depois de fazer a solução de problemas básica?

Outro exemplo : temos scripts de cerca de 20 desenvolvedores, às vezes eles dependem uns dos outros. A ordem do roteiro estava errada. Não consigo acompanhar o trabalho de 20 desenvolvedores e também gerenciar os dados, mas após algumas soluções de problemas, descobrimos o problema e alteramos a ordem. Isso é algo em que o DBA normalmente deve estar profundamente envolvido ou é justo após o teste básico e examinar, enviamos de volta ao gerente de lançamento e aos desenvolvedores para consertar?

Eu gerencio um ambiente de banco de dados misto e nossos programadores podem usar algumas boas opções de reversão. Eu estava pensando em usar SQL Compare, Red Gate Source Control e algumas outras ferramentas, mas não consigo descobrir qual seria a melhor maneira de garantir reversões com perda mínima de dados.

Supondo que estamos em casos extremos, como quando uma chave estrangeira é adicionada a outra tabela que é preenchida com dados do cliente, e precisamos reverter as alterações na tabela primária. Quais são algumas das práticas recomendadas padrão do setor para garantir reversões suaves fora de restaurações de log de transações, restaurações de instantâneos, controle de fonte redgate etc. para lidar com esses cenários mais difíceis de recuperar?

Obrigado!

Estou projetando uma solução de expansão para uma empresa globalmente dispersa que possui data centers em todos os continentes. Mais de 10.000 servidores se reportam a um cluster do SQL Server em Los Angeles e também o consultam para executar determinadas tarefas.

A Justificativa/Razão

Para passar de clusters, os problemas com escala vertical e melhorar o desempenho devido à distância global da rede entre muitos nós para o cluster em LA, pensei em usar a replicação transacional em tabelas de núcleo específicas para assinantes (single pub multi sub) espalhado pelo mundo como meu primeiro passo.

Problema a ser resolvido

Se, por qualquer motivo, os dados tiverem mais de X minutos (digamos, 10 minutos), quero que eles acessem o editor (ou outro servidor definido) e os leiam a partir daí. Gostaria de obter dados automaticamente da instância do editor se a preferida não estiver disponível ou desatualizada.

Não tenho certeza de qual é o melhor método para fazer isso, especialmente se os dados estiverem 'obsoletos'. Sei que temos ferramentas de monitoramento de replicação, mas como eu usaria isso para saber se os dados estão obsoletos e forçar as conexões com outro servidor que não esteja?

O motivo é que estou preocupado que certos problemas demorem mais de 10 minutos para serem resolvidos. Durante esse período, os aplicativos críticos, como manutenção e provisionamento automático, obterão dados obsoletos e os negócios poderão ser bastante afetados.

Possíveis soluções e problemas com eles:

Coloque os assinantes/editor em um balanceador de carga 'somente leitura' e faça todas as consultas irem para lá.

Se os servidores de banco de dados estivessem todos no mesmo datacenter, eu provavelmente usaria um balanceador de carga e retiraria os servidores dele, mas isso exigirá intervenção manual e quero que o sistema force todas as leituras para o publicador (ou outro assinante) e ignorar o assinante ao qual eles se conectam.

No entanto, isso não resolveria o problema com dados obsoletos , como se a replicação atrasasse e levasse uma hora para ser corrigida.

Modifique o código para verificar consultas replicadas pendentes e ajuste de acordo

Isso exigiria modificações de código em muitas consultas e os desenvolvedores não teriam o ciclo para fazer isso, além de não parecer uma ideia muito plausível.

Consulte o status da replicação e altere a cadeia de conexão automaticamente se um número X de consultas não for replicado

Eu deveria ser capaz de fazer isso no Powershell, mas a maioria dos servidores é Linux, então eles precisam de um 'aplicativo' que consulte o status de replicação e modifique sua string de conexão se estiver acima de um número X de comandos não replicados.

Obrigada! Tenho 1 ambiente de 2012 e vários ambientes de 2008 nos quais gostaria de implementar isso, com a ideia de movê-los todos para 2012. Enterprise é uma opção.

Outras ponderações

Ter um balanceador de carga em LA para o qual o mundo envia uma pequena consulta muito rápida, para decidir qual servidor escolher, pode funcionar bem, na verdade, pois seria uma pequena consulta e talvez o final solicitante pudesse armazenar em cache essas informações temporariamente.

Parece que eu teria que ter o SQL ou outro mecanismo de banco de dados que é o par 'somente leitura' devolvido ao aplicativo 'esses dados estão obsoletos, vá para outro lugar, de preferência aqui'

Gostaria de excluir cerca de 100.000 registros com sobrecarga mínima do servidor. Eu tive algumas perguntas incômodas que não pude testar corretamente, então decidi perguntar a alguns especialistas aqui. Qual seria melhor:

1-

BEGIN TRAN
DELETE FROM dbo.x
WHERE ID IN (
1
,2
,3
,4
...
,100000
)
COMMIT

2-

BEGIN TRAN
DELETE FROM dbo.x
WHERE ID = 1
GO
DELETE FROM dbo.x
WHERE ID = 2
GO
...
COMMIT 

3-

DELETE FROM dbo.x
WHERE ID = 1
GO
DELETE FROM dbo.x
WHERE ID = 2
GO
...

Minha suposição é que o nº 1 causaria uma varredura com base na % de amostra, escolheria os itens, removeria-os e registraria como uma série de transações. Talvez baseasse as informações no log de transações sobre quais páginas foram alteradas em vez de cada indvl. transação, portanto, você só pode reverter toda a atividade e remarcar as páginas, ou você pode confirmar. Isso está correto?

Em # 2, estou pensando se a instrução GO causa muito mais atividade de log de transações, não permitindo que o SQL Server Storage Engine role tudo isso em uma transação grande, mas ainda fornece alguma otimização para o log de transações com o BEGIN TRAN - Blocos COMMIT, tornando-o mais eficaz que o #3, mas menos eficaz que o #1.

Eu então assumiria que o nº 3 seria o pior, pois cada indvl. transação é registrada.

Se alguém tiver boas postagens de blog ou cenários de teste que possam me indicar, isso também seria ótimo. Procurei maneiras de me aprofundar no log de transações para descobrir sozinho, mas, neste ponto, pensei em perguntar a vocês.

Obrigado!

Eu esperava obter uma resposta clara sobre como garantir um backup completo do Postgres, assim como você obteria com o MS SQL Server e, em seguida, cuidar de usuários órfãos.

Pelo que li, e pode estar errado, encontrar um bom blog PostgreSQL tem sido um desafio, então sinta-se à vontade para recomendar alguns para mim, preciso descobrir como esse aplicativo funciona para poder confiar nos meus backups e no Slony replicação. Eu pedi a um desenvolvedor para restaurar um backup que tirei do PgadminIII via custom, directory, e tarformat enquanto selecionava OIDs, mas ele disse que dois deles não carregaram, tarmas era apenas o diretório, não os dados. Estou realmente confuso agora.

1. Estou usando o PGAdminIII, ele tem uma opção pg_dumpe pg_dumpall. Quero fazer backup de tudo o que preciso para testar a restauração desse banco de dados em algum lugar e verificar se sim, todos os dados que precisamos e nosso backup é bom. Eventualmente, quero escrever um script de restauração automática, mas um dia de cada vez.

pg_dumpallaparentemente tem uma -globalsopção que deveria fazer backup de tudo, mas a ajuda para pg_dumpallmostra uma opção -g, --globals-only dump only global objects, no databases, não uma --globalsopção.

Eu pensei pg_dumpallque pelo menos faria backup de chaves estrangeiras, mas mesmo isso parece ser uma 'opção'. De acordo com a documentação , mesmo pg_dumpallque eu precise usar uma -oopção para fazer backup de chaves estrangeiras, não consigo imaginar quando não gostaria de fazer backup de chaves estrangeiras e isso faria mais sentido como opções padrão.

2. Como cuidaria de usuários órfãos e validaria que tenho tudo? Eu gostaria de restaurar meu arquivo de backup em outro servidor e verificar se tudo funciona. Se alguém tiver alguma sugestão de como fazer um backup real no PostgreSQL e restaurar, ficaria muito grato.

Eu tinha um servidor PostgreSQL, mas ainda não consigo entender por que o aplicativo não faria backup OIDde s por padrão! Parece que 99,9% das vezes você gostaria disso.

ATUALIZAÇÃO 1:

A documentação do Postgres menciona que a globalsopção que eu estava procurando parece ser uma opção padrão nesta versão, mas ainda precisa da -oopção. Se alguém puder verificar ou me dar um comando de exemplo para restaurar um único banco de dados em outro lugar com tudo o que precisa, eu agradeceria.

Edit: sendo solicitado pelo site para mostrar a singularidade desta pergunta editando minha pergunta. Essa questão levanta o problema e obtém clareza sobre OIDs em backups, a diferença entre globais e não globais, bem como testar recomendações de restauração para garantir que o backup seja bom, em vez de apenas fazer backup. Devido às respostas, consegui fazer backup, descobrir globals/oids e iniciar um processo de restauração de teste todas as noites no Postgres usando cron jobs. Obrigado pela ajuda!