Quali sono le migliori pratiche per la sicurezza in modo permanente l'eliminazione di un database?

Question

Abbiamo un ambiente di "organico", che significa la gente codice accatastati sul codice per anni dieci con la supervisione minimo o documentazione. L'utilizzo del server che ha diverse basi di dati che a mio avviso non sono più in uso; Mi piacerebbe eliminarli e lasciare solo tre Io in realtà uso.

Al limite spericolata, ho potuto disattivare questi database e aspettare che qualcuno da urlo; all'altra potevo lasciarli correre per sempre "just in case". Cosa avete trovato prezioso per identificare se si utilizza un server e come?

Inoltre, quali misure raccomanderebbe per garantire che, come ci si muove in avanti nei sistemi invalidanti, che rimangono comodamente reversibile per un periodo di tempo (ad esempio, rinominare gli oggetti anziché eliminarne a titolo definitivo)?

Grazie!

Answer 1

Si vuole anche assicurarsi che le datetime francobolli di ogni tavolo. Cerca i metadati nel sistema per ogni tabella, ordine tale lista un sottoprodotto datetime aggiornato scorso, e visualizzare l'output in ordine decrescente per datetime. Si potrebbe anche verificare le dimensioni della tabella anche per il leggero cambiamento di dimensione.

Per esempio, in MySQL 5.x, avete INFORMATION_SCHEMA.TABLES che assomiglia a questo:

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)

L'UPDATE_TIME colonna registra l'ultima volta che un INSERT, UPDATE o DELETE è entrata l'ultima applicato alla tabella. Si potrebbe eseguire query come questi per sapere quando ogni database è stato l'ultimo accesso:

L'ultima volta che una tabella è stata letta in ogni database:

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;

L'ultima volta che una tabella è stata letta in qualsiasi database:

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

Ultimi 10 date una tabella è stata letta:

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;

Questi sono solo alcuni esempi di come ottenere tali metadati da MySQL. Sono sicuro che Oracle e SQL Server hanno metodi simili o migliori.

Una volta che siete sicuri di quanto spesso o raramente si accede un database (o schema), si dovrebbe discarica manualmente / export database di età compresa insieme alle copie dello schema si distingue dai dati. Si prega di scusa che la mia risposta non è DB agnostico. SQLServer e Oracle DBA dovrebbe esprimere le loro risposte anche qui, dal momento che il concetto di uno schema di essere un insieme all'interno di un'istanza del database è sfocata in MySQL, ma molto seguito rigorosamente in SQLServer e Oracle.

Answer 2

Si potrebbe provare a impostare una traccia che solo cattura i collegamenti e in quale banca dati si collegano a. Vorrei lasciare questa corsa per un po 'e poi assicurarsi che nulla si sta collegando ad esso.

Un problema con che sarebbe se si dispone di un codice aprendo sul master db, ma chiamare un altro DB all'interno del codice. Non sono sicuro di quanto male il codice è che sta puntando al tuo DB.

Mi piacerebbe anche interrogare tutti i lavori e assicurarsi che nessuno stanno indicando che DB

Si potrebbe anche usare revisione SQL se avete la giusta versione di SQL (2008 R2 Enterprise).

Si potrebbe anche usare l'accesso trigger per aggiornare una tabella quando qualcuno il login per quel DB. Ciò mostrerà se qualcosa stava collegando a questo DB.

Answer 3

Inoltre, quali passi mi consiglia di assicurare che, come ci si muove in avanti nei sistemi invalidanti, che rimangono comodamente reversibile per un periodo di tempo

In SQL Server, si può prendere i database " offline ", che lascia il database presente , ma permette la connessione ad esso tramite codice non possibile. Se un database è "offline" rimane ancora disponibile ed è reversibile in pochi minuti.

Al mio ultimo lavoro abbiamo avuto alcuni prodotti già in servizio per diversi mesi all'anno, in modo da spegnere, o prendendo in linea, il database per mesi in un momento non sarebbe stato notato dalle persone che lavorano con quel prodotto. Come un esempio, uno dei prodotti coinvolti W-2 forme, così il 98% del business avviene in gennaio e febbraio (per la maggior parte delle aziende, i dati non sono disponibili fino alla prima settimana di gennaio, e il termine regolamentare federale per la presentazione della informazioni è l'ultimo giorno lavorativo di gennaio). Il server web è stato di solito spento da maggio / giugno fino a dicembre.

A tale società, abbiamo avuto un foglio di calcolo con il "proprietario" del database - una sola persona responsabile del prodotto. Mentre gli altri potrebbero fare gli aggiornamenti alla struttura delle tabelle, il "proprietario" è stato il go-to persona quando tutte le domande dovevano essere chiesto. Se il proprietario ha lasciato l'azienda (rara fino all'anno scorso), qualcuno verrebbe assegnato ad essere il nuovo proprietario prima di partire.

banche dati presso altre società, abbiamo offline per un quarto, se rimangono in linea con niente di rottura (come mese / relazioni trimestrali), fatto il backup per l'ultima volta e cancellati. Questo permette a qualcuno di poi tornare indietro e ripristinare il database (che richiede pochi minuti) per quelle situazioni che hanno storie come "Oh, è stato per il progetto jones che abbiamo dovuto mettere da parte, mentre abbiamo ottenuto il progetto di fred finito."