Quais são as práticas recomendadas para excluir permanentemente um banco de dados com segurança?

Você pode tentar configurar um rastreamento que capture apenas conexões e a qual banco de dados elas se conectam. Eu deixaria isso rodando um pouco e depois me certificaria de que nada está se conectando a ele.

Um problema com isso seria se você tivesse algum código abrindo no banco de dados mestre, mas chamando outro banco de dados dentro do código. Não tenho certeza de quão ruim é o código que está apontando para seus bancos de dados.

Eu também consultaria todos os seus trabalhos e garantiria que nenhum apontasse para esse banco de dados

Você também pode usar a auditoria SQL se tiver a versão correta do SQL (2008 R2 Enterprise).

Você também pode usar gatilhos de logon para atualizar uma tabela quando alguém fizer logon nesse banco de dados. Isso mostraria se algo estava se conectando a esse banco de dados.

Você também deseja certificar-se dos carimbos de data e hora de cada tabela. Pesquise quaisquer metadados no sistema para cada tabela, ordene essa lista por data e hora da última atualização e exiba a saída em ordem desc por data e hora. Você também pode verificar o tamanho da mesa, mesmo para uma pequena mudança de tamanho.

Por exemplo, no MySQL 5.x, você tem information_schema.tables que se parece com isto:

mysql> desc information_schema.tables;
+-----------------+---------------------+------+-----+---------+-------+
| Field           | Type                | Null | Key | Default | Extra |
+-----------------+---------------------+------+-----+---------+-------+
| TABLE_CATALOG   | varchar(512)        | NO   |     |         |       |
| TABLE_SCHEMA    | varchar(64)         | NO   |     |         |       |
| TABLE_NAME      | varchar(64)         | NO   |     |         |       |
| TABLE_TYPE      | varchar(64)         | NO   |     |         |       |
| ENGINE          | varchar(64)         | YES  |     | NULL    |       |
| VERSION         | bigint(21) unsigned | YES  |     | NULL    |       |
| ROW_FORMAT      | varchar(10)         | YES  |     | NULL    |       |
| TABLE_ROWS      | bigint(21) unsigned | YES  |     | NULL    |       |
| AVG_ROW_LENGTH  | bigint(21) unsigned | YES  |     | NULL    |       |
| DATA_LENGTH     | bigint(21) unsigned | YES  |     | NULL    |       |
| MAX_DATA_LENGTH | bigint(21) unsigned | YES  |     | NULL    |       |
| INDEX_LENGTH    | bigint(21) unsigned | YES  |     | NULL    |       |
| DATA_FREE       | bigint(21) unsigned | YES  |     | NULL    |       |
| AUTO_INCREMENT  | bigint(21) unsigned | YES  |     | NULL    |       |
| CREATE_TIME     | datetime            | YES  |     | NULL    |       |
| UPDATE_TIME     | datetime            | YES  |     | NULL    |       |
| CHECK_TIME      | datetime            | YES  |     | NULL    |       |
| TABLE_COLLATION | varchar(32)         | YES  |     | NULL    |       |
| CHECKSUM        | bigint(21) unsigned | YES  |     | NULL    |       |
| CREATE_OPTIONS  | varchar(255)        | YES  |     | NULL    |       |
| TABLE_COMMENT   | varchar(2048)       | NO   |     |         |       |
+-----------------+---------------------+------+-----+---------+-------+
21 rows in set (0.01 sec)

A coluna UPDATE_TIME registra a última vez que qualquer INSERT, UPDATE ou DELETE foi aplicado pela última vez à tabela. Você pode executar consultas como estas para descobrir quando cada banco de dados foi acessado pela última vez:

Última vez que uma tabela foi acessada em cada banco de dados:

SELECT table_schema,MAX(update_time) last_accessed
FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema','mysql')
AND update_time IS NOT NULL
GROUP BY table_schema;

Última vez que uma tabela foi acessada em qualquer banco de dados:

SELECT MAX(update_time) last_accessed FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema','mysql');

As últimas 10 datas em que uma tabela foi acessada:

SELECT * FROM
(SELECT * FROM
(SELECT last_accessed,COUNT(1) access_count
FROM (SELECT DATE(update_time) last_accessed
FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema','mysql')
AND update_time IS NOT NULL) A
GROUP BY last_accessed) AA
ORDER BY last_accessed DESC) AAA
LIMIT 10;

Estes são apenas alguns exemplos de como obter esses metadados do MySQL. Tenho certeza de que o Oracle e o SQL Server têm métodos semelhantes ou melhores.

Depois de ter certeza de quantas vezes ou raramente um banco de dados (ou esquema) é acessado, você deve despejar/exportar manualmente bancos de dados antigos junto com cópias do próprio esquema, além dos dados. Por favor, desculpe que minha resposta não é agnóstica em DB. Os DBAs SQLServer e Oracle também devem expressar suas respostas aqui, já que o conceito de um esquema sendo uma coleção dentro de uma instância de banco de dados é confuso no MySQL, mas seguido estritamente no SQLServer e no Oracle.

Além disso, quais etapas você recomendaria para garantir que, à medida que avançamos na desativação dos sistemas, eles permaneçam convenientemente reversíveis por um período de tempo

No SQL Server, você pode colocar bancos de dados " offline " o que deixa o banco de dados presente, mas impossibilita a conexão com ele via código. Se um banco de dados estiver "offline", ele ainda estará disponível e poderá ser revertido em minutos.

No meu último trabalho, tínhamos alguns produtos que estavam em operação por vários meses por ano, portanto, desligar ou desligar o banco de dados por meses a fio não seria notado pelas pessoas que trabalham com esse produto. Por exemplo, um dos produtos envolvia formulários W-2, então 98% dos negócios acontecem em janeiro e fevereiro (para a maioria das empresas, os dados não estão disponíveis até a primeira semana de janeiro e o prazo regulamentar federal para arquivar o informação é o último dia útil de janeiro). O servidor web geralmente era desligado de maio/junho até dezembro.

Naquela empresa, tínhamos uma planilha com o "dono" do banco de dados - um único responsável pelo produto. Enquanto outros poderiam fazer atualizações na estrutura das tabelas, o "proprietário" era a pessoa a quem recorrer quando qualquer pergunta precisava ser feita. Se o proprietário deixasse a empresa (raro até o ano passado), alguém seria designado para ser o novo proprietário antes de ele sair.

Em outras empresas, deixamos os bancos de dados offline por um trimestre, se eles ficarem offline sem nada quebrar (como relatórios mensais/trimestrais), eles recebem backup uma última vez e são excluídos. Isso permite que alguém volte mais tarde e restaure o banco de dados (o que leva alguns minutos) para aquelas situações que têm histórias como "oh, isso foi para o projeto jones que tivemos que deixar de lado enquanto terminávamos o projeto fred".