Petar Karan

[steam] Steam o il gioco non si apre senza riavviare il PC

Problema: dopo aver giocato e chiuso il gioco o Steam, quando si cerca di rilanciare un gioco o Steam stesso, nessuno dei due parte, finché non si riavvia il computer

Questo problema è cominciato ad apparire di recente, senza motivo apparente, ed anzi per un po’ ho pensato che potesse essere collegato in qualche modo a Final Fantasy XV, che avevo installato da poco (ma poi ho scoperto non essere il colpevole). Leggendo in giro ho trovato svariate soluzioni, tra le quali si suggeriva addirittura di disinstallare e reinstallare Steam, e riavviare il PC è comunque una bella seccatura, specialmente se si vuole giocare senza dover chiudere per forza tutti i programmi che si avevano aperti.

La soluzione che per me ha funzionato è la seguente (testata su Windows 10):

Aprire il task manager ed individuare anzitutto ogni eventuale processo di Steam attivo (per aprirlo premere WIN+R e digitare taskmgr, oppure CTRL+ALT+CANC e poi selezionare Gestione Attività)
Individuare un eventuale programma ancora aperto e chiuderlo, cliccandoci sopra col destro e selezionando Termina attività (in generale a me capita dopo che lo riduco ad icona e non sembra ci sia un programma attivo di Steam, ma solo il processo)
A questo punto individuare il servizio Steam Client Service, cliccare col destro e spostarsi sui dettagli
Nei dettagli dovremmo vedere una serie di processi come nell’esempio seguente, cliccare col destro su ciascuno di loro e scegliere Termina Albero Processi (questo è molto importante per chiudere tutte le istanze di Steam, potreste anche notare che Steam.exe non può essere terminato, dando errore di “Accesso negato“, non ve ne preoccupate)
Fatto questo andiamo su Servizi ed individuiamo Steam Client Service, clicchiamoci sopra col destro e scegliamo Riavvia (oppure Avvia, a seconda dei casi)

A questo punto dovrebbe essere possibile far partire nuovamente Steam ed ogni eventuale gioco che si voglia giocare.

Google non va sulle reti Telecom… per alcuni minuti

Stasera molti utenti delle reti Telecom, in particolare Alice ADSL si sono accorti che Google non andava! A quanto pare il problema stava nell’instradamento delle connessioni sulla rete Telecom, che anziché seguire il percorso di tutti gli altri, finivano in Brasile, come riportato da alcuni utenti su Twitter. Su tutte le altre reti si navigava normalmente.

Gli instradamenti, quelli belli!#GoogleDown @TIM_Official perchè le routes ci portano in brasile? pic.twitter.com/zRqaMaPR8Z

— Fabrizio Pi π (@F4bri92) 4 aprile 2018

#googledown instradamento verso il Brasile non mi convince per nulla@Google @googleitalia @TIM_Official pic.twitter.com/SvTyiBd2wv

— mrbyte (@mrbyte72) 4 aprile 2018

Il normale percorso che avrebbe dovuto seguire sarebbe stato simile a questo (io esco da Fastweb, ma dopo il percorso dovrebbe essere uguale):

[ubuntu] Aggiungere virtual host, ovvero aggiungere dominio su server Apache

Immaginiamo di avere un dominio che punta all’indirizzo IP del nostro server, per esempio petarkaran.it indirizzato su 82.165143.26. Affinché al dominio risponda Apache con un sito web è necessario aggiungere un virtual host opportunamente configurato.

Per farlo anzitutto creiamo la cartella del nostro sito. Spostiamoci su /var/www

cd /var/www

1	cd /var/www

E creiamo una cartella, a nostro piacere, che di solito si nomina come il dominio (ma non è obbligatorio):

sudo mkdir petarkaran.it

1	sudo mkdir petarkaran.it

Affinché Apache ci possa lavorare correttamente è necessario riassegnarle l’utente opportuno, cioè www-data, visto che in questo modo il proprietario della cartella è root:

sudo chown www-data:www-data petarkaran.it

1	sudo chown www-data:www-data petarkaran.it

Adesso creiamo il file di configurazione del virtual host, per farlo spostiamoci su:

cd /etc/apache2/sites-available/

1	cd /etc/apache2/sites-available/

A questo punto creiamo il nostro file:

sudo nano petarkaran.it.conf

1	sudo nano petarkaran.it.conf

Possiamo anche copiarlo da un file esistente, per esempio:

sudo cp 000-default.conf petarkaran.it.conf

1	sudo cp 000-default.conf petarkaran.it.conf

Qualora avessimo creato il file di sana pianta incolliamo dentro il seguente contenuto base:

<VirtualHost *:80>
        ServerName petarkaran.it
 
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/petarkaran.it
 
        ErrorLog \${APACHE_LOG_DIR}/error.log
        CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

ServerName petarkaran.it

ServerAdmin webmaster@localhost

DocumentRoot /var/www/petarkaran.it

ErrorLog \${APACHE_LOG_DIR}/error.log

CustomLog \${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

Per abilitare il sito digitiamo:

sudo a2ensite petarkaran.it
sudo service apache2 reload

1 2	sudo a2ensite petarkaran.it sudo service apache2 reload

Adesso al nostro dominio, sulla porta 80, risponde Apache con il sito sulla suddetta cartella.

[excel] Copiare solo celle visibili e non quelle nascoste

Problema: Quando si seleziona un gruppo di celle e si copiano normalmente, vengono copiate anche le celle nascoste, mentre si vorrebbero copiare solamente le celle visibili

Immaginiamo di avere un intervallo di celle come il seguente:

Se adesso decidessimo di nascondere la terza riga avremmo il seguente risultato:

Selezionando l’intervallo A1:B5 e copiando (per esempio con CTRL+C) copieremo in realtà anche la riga 3 che è nascosta. Lo stesso vale quando si utilizzano i filtri sulle celle.

Per copiare invece solamente le celle visibili dobbiamo fare nel modo seguente:

Selezioniamo l’intervallo che vogliamo copiare come faremmo normalmente
Nella scheda Home spostiamoci su Trova e seleziona e selezioniamo Vai a formato speciale…
Nella finestra selezioniamo Solo celle visibili e premiamo Ok
Eseguiamo la copia come faremmo normalmente (o banalmente premendo CTRL+C)

Adesso abbiamo copiato solo le celle visibili e possiamo incollarle dove vogliamo.

Per maggiori approfondimenti consiglio la guida ufficiale di Office: Copiare solo le celle visibili

[php] Interroghiamo un database MySQL su cluster mediante il PHP

Obiettivo: anzitutto creiamo una classe per mediare la connessione MySQL (con o senza cluster è indifferente) e testiamo il cluster MySQL creato nell’esercizio precedente

Per realizzare il nostro scopo avviamo un server apache sulla nostra macchina host, dove abbiamo già avviato 3 macchine virtuali che costituiscono il nostro MySQL Cluster.

Per avviare il server apache mi avvarrò di XAMPP.

Inoltre prima di procedere devo inoltrare la porta 3306 verso il MySQL Cluster Manager che ho configurato in precedenza. Per farlo mi è sufficiente spostarmi in File ⇒ Preferenze ⇒ Rete

Selezioniamo la nostra Rete NAT corrispondente al cluster che abbiamo realizzato e andiamo a configurare l’inoltro delle porte, per ottenere qualcosa di simile a questo:

A questo punto andiamo nel nostro PHP. Creiamo anzitutto un file /inc/MySQLDb.php contenente il seguente codice:

class MySQLdb {

	private $mysql = NULL;

	function __construct($cfg = NULL) {
	
		if( $cfg != NULL ) {
			
			$this->config($cfg['dbname'],$cfg['dbhost'],$cfg['dbuser'],$cfg['dbport'],$cfg['dbpass']);
			
			$this->connect_db();
			
		}
	
	}
	
	function __destruct() {
	
		$this->close_db();
	
	}
	
	function config( $dbname, $dbhost, $dbuser, $dbport, $dbpass ) {
	
		$this->dbname = $dbname;
		$this->dbhost = $dbhost;
		$this->dbuser = $dbuser;
		$this->dbport = $dbport;
		$this->dbpass = $dbpass;
	
	}
	
	function select_db($dbname = NULL) {
	
		$this->mysql->select_db($dbname ? $dbname : $this->dbname);
	
	}
	
	function connect_db() {
	
		if( $this->mysql == NULL ) {
		
			$this->mysql = new mysqli($this->dbhost, $this->dbuser, $this->dbpass);
			$this->select_db();
			$this->errorHandler();
		
		}
	
	}
	
	function close_db() {
	
		if( $this->mysql != NULL ) {
		
			$this->mysql->close();
			$this->mysql = NULL;
		
		}
	
	}
	
	function errorHandler() {
	
		if( $this->mysql->connect_errno ) {
		
			printf( "Connect failed: %s\n", $this->mysql->connect_error );
			die();
			
		}
	
	}
	
	function clean( $val ) {
		return $this->mysql->real_escape_string($val);
	}
	
	function in( $query ) {
	
		$status = $this->mysql->query( $query );
		
		if( $this->mysql->insert_id ) 
			return $this->mysql->insert_id;
		else 
			return $status;
	
	}
	
	function out( $query , $autoReduce = true ) {
	
		$result = $this->mysql->query( $query );
			
		if( !is_object($result) )
			return array();
		
		while ($linea = $result->fetch_assoc()) {
		
			$i = $i !== NULL ? $i + 1 : 0;
			
			foreach( $linea as $key => $value ) {
				$dati[$i][$key] = $value;
			}
			
		}
		
		$result->close();
		
		if( count($dati) == 1 && $autoReduce )
			return $dati[0];
		
		return $dati;
	
	}


}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

class MySQLdb {

private $mysql = NULL;

function __construct($cfg = NULL) {

if( $cfg != NULL ) {

$this->config($cfg['dbname'],$cfg['dbhost'],$cfg['dbuser'],$cfg['dbport'],$cfg['dbpass']);

$this->connect_db();

}

function __destruct() {

$this->close_db();

}

function config( $dbname, $dbhost, $dbuser, $dbport, $dbpass ) {

$this->dbname = $dbname;

$this->dbhost = $dbhost;

$this->dbuser = $dbuser;

$this->dbport = $dbport;

$this->dbpass = $dbpass;

}

function select_db($dbname = NULL) {

$this->mysql->select_db($dbname ? $dbname : $this->dbname);

}

function connect_db() {

if( $this->mysql == NULL ) {

$this->mysql = new mysqli($this->dbhost, $this->dbuser, $this->dbpass);

$this->select_db();

$this->errorHandler();

}

function close_db() {

if( $this->mysql != NULL ) {

$this->mysql->close();

$this->mysql = NULL;

}

function errorHandler() {

if( $this->mysql->connect_errno ) {

printf( "Connect failed: %s\n", $this->mysql->connect_error );

die();

}

function clean( $val ) {

return $this->mysql->real_escape_string($val);

}

function in( $query ) {

$status = $this->mysql->query( $query );

if( $this->mysql->insert_id )

return $this->mysql->insert_id;

else

return $status;

}

function out( $query , $autoReduce = true ) {

$result = $this->mysql->query( $query );

if( !is_object($result) )

return array();

while ($linea = $result->fetch_assoc()) {

$i = $i !== NULL ? $i + 1 : 0;

foreach( $linea as $key => $value ) {

$dati[$i][$key] = $value;

}

$result->close();

if( count($dati) == 1 && $autoReduce )

return $dati[0];

return $dati;

}

Andiamo adesso a creare il nostro file index.php:

<?php

	include("inc/MySQLDb.php");
	
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "root",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);
	
	print_r( $utenti );


?>

<?php

include("inc/MySQLDb.php");

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "root",

"dbpass" => "password",

"dbport" => 3306

));

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

print_r( $utenti );

Eseguendo la pagina index.php è molto probabile incorrere nel seguente output di errori:

Warning: mysqli::__construct(): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): Error while reading greeting packet. PID=2612 in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): (HY000/2006): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::select_db(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 37
Connect failed: MySQL server has gone away 
Warning: mysqli::close(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 57

Warning: mysqli::__construct(): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): Error while reading greeting packet. PID=2612 in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): (HY000/2006): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::select_db(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 37

Connect failed: MySQL server has gone away

Warning: mysqli::close(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 57

Questo tipo di errore può dipendere o dal fatto che stiamo richiedendo una query troppo grossa, oppure perché il nostro Server MySQL non è predisposto per accettare le connessioni dall’esterno.

Per risolvere il problema procediamo nel modo seguente.

Anzitutto creiamo un utente apposito con il quale ci collegheremo dall’esterno (nel mio caso gli garantirò tutti i permessi possibili su tutti i database, ovviamente andrebbe limitato ad uno specifico database).

Accediamo al mysql sul nostro cluster manager digitando:

mysql -u root -p

1	mysql -u root -p

Inseriamo la password di root e poi eseguiamo le seguenti due query per creare l’utente zelda:

GRANT ALL PRIVILEGES ON *.* TO 'zelda'@'192.168.56.1' IDENTIFIED BY 'password' WITH GRANT OPTION;
FLUSH PRIVILEGES;

1 2	GRANT ALL PRIVILEGES ON . TO 'zelda'@'192.168.56.1' IDENTIFIED BY 'password' WITH GRANT OPTION; FLUSH PRIVILEGES;

Faccio notare che con ‘zelda’@’192.168.56.1′ garantiamo l’accesso all’utente zelda dall’indirizzo 192.168.56.1 che è l’indirizzo esterno della nostra rete NAT su Virtual Box.

Digitiamo exit per uscire e andiamo a modificare il file di configurazione del mysql:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

1	sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Cerchiamo la voce bind-address e commentiamola in modo che risulti in questo modo:

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
log-error       = /var/log/mysql/error.log
# By default we only accept connections from localhost
#bind-address   = 127.0.0.1
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

[mysqld]

pid-file = /var/run/mysqld/mysqld.pid

socket = /var/run/mysqld/mysqld.sock

datadir = /var/lib/mysql

log-error = /var/log/mysql/error.log

# By default we only accept connections from localhost

#bind-address = 127.0.0.1

# Disabling symbolic-links is recommended to prevent assorted security risks

symbolic-links=0

Infine modifichiamo anche il file /etc/mysql/my.cnf

sudo nano /etc/mysql/my.cnf

1	sudo nano /etc/mysql/my.cnf

Inseriamo in fondo max_allowed_packet=16M in modo tale che il file risulti così

[mysqld]
ndbcluster
max_allowed_packet=16M

[mysqld]

ndbcluster

max_allowed_packet=16M

Quest’ultima modifica è di solito sufficiente per correggere il precedente errore, se dovesse ripresentarsi possiamo alzare ancora questo valore.

Fatto tutto questo riavviamo il servizio mysql digitando:

sudo service mysql restart

1	sudo service mysql restart

Se abbiamo fatto tutto bene non ci saranno errori.

A questo punto modifichiamo il file index.php di sopra perché appaia in questo modo:

<?php

	error_reporting(E_ALL & ~E_NOTICE);

	include("inc/MySQLDb.php");
	
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "zelda",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);
	
	print_r( $utenti );


?>

<?php

error_reporting(E_ALL & ~E_NOTICE);

include("inc/MySQLDb.php");

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "zelda",

"dbpass" => "password",

"dbport" => 3306

));

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

print_r( $utenti );

Eseguendo la pagina dovremmo vedere qualcosa di simile a questo:

Questo significa che è tutto andato correttamente. A questo punto divertiamoci ad inserire qualche altro utente e generare una tabella con HTML corretto. Modifichiamo il file PHP come segue:

<?php

	error_reporting(E_ALL & ~E_NOTICE);

	include("inc/MySQLDb.php");
	
	// connettiamoci al database
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "zelda",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	// inseriamo un nuovo nominativo
	$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi','Verdi')");
	
	// leggiamo tutti gli utenti
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);


?>
<html>

	<head>
		<title>Esempio Cluster MySQL e PHP</title>
	</head>
	
	<body>
	
		<table border="1">
		
			<thead>
				<tr>
					<th>Nome</th>
					<th>Cognome</th>
				</tr>
			</thead>
			
			<tbody>
				<?php foreach( $utenti as $k => $v ) { ?>
				<tr>
					<td><?php echo $v['nome'] ?></td>
					<td><?php echo $v['cognome'] ?></td>
				</tr>
				<? } ?>
			</tbody>
			
		</table>
		
	</body>

</html>

<?php

error_reporting(E_ALL & ~E_NOTICE);

include("inc/MySQLDb.php");

// connettiamoci al database

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "zelda",

"dbpass" => "password",

"dbport" => 3306

));

// inseriamo un nuovo nominativo

$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi','Verdi')");

// leggiamo tutti gli utenti

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

<html>

<head>

<title>Esempio Cluster MySQL e PHP</title>

</head>

<body>

<thead>

<tr>

<th>Cognome</th>

</tr>

</thead>

<tbody>

<?php foreach( $utenti as $k => $v ) { ?>

<tr>

</tr>

<? } ?>

</tbody>

</table>

</body>

</html>

Il risultato, aggiornando la pagina, dovrebbe essere simile a questo:

Infine facciamo una prova per caricare di dati il nostro cluster.

Modifichiamo il file index.php alterando la parte dell’inserimento degli utenti come segue:

	// inseriamo un nuovo nominativo
	for( $i = 0; $i < 10000; $i++ )
		$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi$i','Verdi$i')");

// inseriamo un nuovo nominativo

for( $i = 0; $i < 10000; $i++ )

$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi$i','Verdi$i')");

Prima di aggiornare la pagina andiamo nel nostro cluster manager e digitiamo:

ndb_mgm -e 'ALL REPORT MEMORYUSAGE'

1	ndb_mgm -e 'ALL REPORT MEMORYUSAGE'

Quello che dovremmo vedere sarà un risultato simile a questo:

Inserendo 10.000 record, con il precedente script, dovremmo vedere questa “importante” differenza:

Recensione disonesta su Noctis in Tekken 7

Me n’ero quasi dimenticato che ci sarebbe stato, quando finalmente, lo scorso 20 marzo, al cast di Tekken 7 si è aggiunto anche Noctis da Final Fantasy XV. Questa naturalmente non potrà che essere una recensione disonesta, dal momento che si fondono insieme due delle mie saghe preferite.

Noctis fa letteralmente il botto. E’ una specie di sintesi perfetta tra Jun, Hwoarang e Kazumi (miei combattenti preferiti). Similmente a Jun, ha alcune perfette aperture dall’alto (uf+3, u+2), mentre con Kazumi condivide quelle dal basso che rompono veramente un sacco le scatole (df+2) e la possibilità di raggiungere l’avversario a distanza (f,f+2). Comunque niente di assurdo tipo il raggio di Devil Kazuya o Devil Jin. Con Hworang non condivide tanto i calci, quanto alcune semplicissime pressioni di tasti che si trasformano in velocissime combo (Blitz Rush con 2,2,2,2,2) e alcuni sgambetti (d+4, combinabile in d+4,1,1+2), oltre che la velocità. A parte questi piccoli apprezzamenti squisitamente personali (Jun è stata in assoluto il mio personaggio preferito dell’intera saga), l’intero set di mosse è molto coreografico e bello da vedere, per quanto di per se solo alcuni colpi siano veramente devastanti (diciamo che vige la regola dei tanti piccoli colpi ben assestati).

Molti si sono lamentati che non c’entri molto con Tekken, anche se sinceramente non sono d’accordo (sebbene ammetto di essere molto di parte); in questo ultimo capitolo si schiera nella risma dei personaggi dotati di armi alla Alisa e Yoshimitsu, e coniuga alla perfezione molto caratteristiche dei personaggi maschili (tipicamente colpi forti e lenti) con quelli dei personaggi femminili (colpi deboli, ma veloci). Personalmente lo trovo un mix perfetto.

Inoltre, a differenza degli ultimissimi DLC, non ci sono mosse poco tekkenose, tipo combinazioni b,f o semicerchi in stile Akuma, per quanto mi renda conto che quelle sono necessariamente derivative dai giochi originali. A tal proposito potrei citare il caso di Kazumi, personaggio comunque originale, della quale uno dei linker migliori si esegue premendo b,f (per esempio il Tiger Demon’s Gate, b,f,2,1,4), che trovo abbastanza scomodo (sarà anche per via del tipo di joystick, ma tant’è).

L’unica pecca vera è la scarsità di costumi, che mi ha lasciato un poco deluso, mentre per Geese, Eliza ed Akuma (che ok, non è un DLC, ma è comunque un personaggio esterno) le possibilità di personalizzazione equivalgono a quelle dei personaggi regolari.

Insomma se siete appassionati come il sottoscritto di entrambe le saghe questo non ve lo potete proprio perdere.

Infine segnalo un ottimo video di combo che ho trovato su youtube e sul quale mi sto ancora esercitando, per tutti quelli che volessero approfondire.

[ubuntu] Creare cluster MySQL

Obiettivo: creare un cluster MySQL, ovvero un server MySQL distribuito, utilizzando 3 macchine con Ubuntu, 1 per il gestore del server e 2 per i nodi

Anche questa volta, come negli altri esempi, mi avvarrò di VirtualBox, per emulare il gruppo di server. Ovviamente la procedura è valida anche su macchina fisiche oppure utilizzando un altro tipo di macchine virtuali. La struttura che andremo a creare sarà la seguente:

1. Preparazione di Ubuntu su VirtualBox

Anzitutto scarichiamo ed installiamo VirtualBox dal sito ufficiale.

Quello che voglio creare, prima di cominciare con la configurazione del cluster, sono 3 macchine con sopra Ubuntu perfettamente identiche. Sottolineo il fatto che non sia necessario che siano identiche, ma solo che su tutte e tre sia configurato correttamente il MySQL.

Cominciamo configurando la prima macchina virtuale per metterci sopra Ubuntu.

Come parametri di configurazione, nella procedura guidata, scegliamo:

Versione: Ubuntu (64-bit)
Dimensione memoria: 1024MB
Disco virtuale: 10GB
Tipo di disco: VDI
Tipo allocazione: dinamica

Una volta creata la macchina virtuale facciamo partire ed inseriamo la ISO per l’installazione che abbiamo scaricato dal sito ufficiale di Ubuntu. Ricordo di scaricare la versione Ubuntu Server 64-bit.

Per questo esempio utilizzerò la versione 16.04.2 di Ubuntu Server.

Avviamo normalmente l’installazione, per chi non l’avesse mai fatto suggerisco di seguire la prima parte di: Installazione Ubuntu webserver pronto all’uso [per esordienti totali]

L’unica differenza è che non installeremo il server apache al momento in cui ci verrà richiesto.

Come nome del host mettiamo ubuntu-mysql-manager (si tratta comunque di un nome a piacere):

Ad un certo punto dell’installazione ci verrà proposto quanto segue:

Assicuriamoci di aver selezionato solamente le voci della figura precedente, per selezionarle muoviamoci con le frecce direzionali e spuntiamo le voci premendo SPAZIO. Con la tabulazione spostiamoci su Continua e premiamo INVIO dopo aver selezionato le voci correttamente.

Una volta completata l’installazione riavviamo la macchina virtuale ed entriamo con il nome utente che abbiamo creato.

A questo punto spegniamo la macchina virtuale digitando:

sudo shutdown -t now

1	sudo shutdown -t now

Prima di procedere vogliamo creare una rete NAT interna sulla quale testare le nostre macchine. Per farlo utilizziamo le impostazioni di virtual box andando su File ⇒ Preferenze (oppure premendo CTRL+G dal panello di controllo di virtual box). A questo punto spostiamoci su Rete nel modo seguente e scegliamo di aggiungere una nuova rete.

Una volta creata la nuova rete dovremmo vedere comparire una voce NatNetwork come nell’immagine seguente:

Una volta selezionata clicchiamo sul pulsante per modificarla ed impostiamola nel modo seguente:

Faccio notare che l’impostazione della rete è arbitraria e a nostra scelta, quella predefinita parte sulla configurazione 10.0.2.0/24 che ho modificato nella classica rete domestica col 192.168.0.0/24 a titolo di esercizio. Questo significa che avremo a disposizione 254 host dal 192.16.0.1 al 192.16.0.254.

Diamogli OK e andiamo nelle impostazioni della macchina virtuale mettendo nella configurazione di rete la rete appena creata, in maniera seguente:

Riavviamo la macchina virtuale e colleghiamoci in SSH effettuando l’inoltro delle porte.

Per farlo, una volta partita la macchina virtuale, digitiamo:

ifconfig

ifconfig

Il risultato dovrebbe essere qualcosa di simile a questo:

Nel mio caso noto che la macchina virtuale, di quello che diventerà il manager, si trova all’indirizzo 192.168.0.5 distribuito dal DHCP. Tornando su File ⇒ Preferenze andiamo sulla rete creata prima e apriamo le configurazioni, poi clicchiamo su Inoltro delle porte e aggiungiamo la seguente regola:

Diamo OK. Adesso possiamo collegarci in SSH dalla nostra macchina host (detto banalmente: dal nostro PC che ospita le macchine virtuali) usando l’indirizzo 192.168.56.1 porta 22.

Fatta questa bella impostazione possiamo passare al passaggio successivo.

2. Installazione MySQL sul primo Nodo

Anzitutto installiamo il cluster su tutti i nostri nodi, nello specifico lo installiamo sulla macchina appena creata che poi duplicheremo opportunamente. Per l’installazione possiamo seguire i passaggi indicati sul sito ufficiale, oppure scaricare dalla pagina ufficiale i file .deb necessari.

Io utilizzerò la repository APT, ma prima di cominciare installiamo le dipendenze necessarie al funzionamento del cluster:

sudo apt-get install python-paramiko libclass-methodmaker-perl libaio1

1	sudo apt-get install python-paramiko libclass-methodmaker-perl libaio1

A questo punto dobbiamo installare la MySQL APT Repository sul nostro sistema. Per farlo ci è sufficiente scaricare il file di installazione dal sito ufficiale andando qui. Nello specifico digitiamo:

wget https://dev.mysql.com/get/mysql-apt-config_0.8.9-1_all.deb

1	wget https://dev.mysql.com/get/mysql-apt-config_0.8.9-1_all.deb

Una volta scaricato il file procediamo all’installazione:

sudo dpkg -i mysql-apt-config_0.8.9-1_all.deb

1	sudo dpkg -i mysql-apt-config_0.8.9-1_all.deb

A questo punto ci verrà chiesto che cosa intendiamo configurare e scegliamo la voce MySQL Server & Cluster:

Ci verrà chiesta la versione che intendiamo installare e selezioniamo mysql-cluster-7.6:

A questo punto torniamo alla schermata precedente e selezioniamo OK:

A questo punto non ci rimane che installare il componente base per tutti i nodi digitando:

sudo apt-get update
sudo apt-get install mysql-cluster-community-server

1 2	sudo apt-get update sudo apt-get install mysql-cluster-community-server

L’update ci serve per aggiornare la repository dopo le recenti modifiche, altrimenti è probabile che sia impossibile trovare mysql-cluster-community-server.

Ad un certo punto ci verrà chiesto di impostare una password per l’utente root del database, impostiamo una password e segniamocela da qualche parte. Ricordo che l’utente root non è quello del sistema, ma del database.

A questo punto abbiamo preparato un nodo.

Replicheremo questo nodo per altre due volte, designando un singolo nodo come manager del cluster.

3. Replica dei nodi

Per replicare i nodi possiamo decidere di creare un’immagine del nostro sistema che reinstalleremo a piacere, oppure, visto che stiamo usando VirtualBox di duplicare le macchine virtuali. Quindi spegniamo la nostra macchina e creiamone una copia.

Per farlo ci è sufficiente cliccare sulla macchina virtuale e selezionare Clona…

A questo punto ci verrà mostrata una schermata delle opzioni da configurare nel modo seguente:

Spuntiamo l’inizializzazione di un nuovo indirizzo MAC (visto che vogliamo usare le macchine insieme) e diamo un nome alla nuova macchina, nel mio caso Ubuntu MySQL Nodo 1.

Ripetiamo la medesima operazione per creare un Ubuntu MySQL Nodo 2.

A questo punto sistemiamo la nostra rete per poter accedere alle macchine virtuali. Per farlo assegniamo a tutte le macchine un indirizzo IP statico, modifichiamo opportunamente i nomi e configuriamo il file hosts in modo tale che possano vedersi le une con le altre. La configurazione finale sarà così:

Cominciamo con Ubuntu MySQL Manager.

Usando ifconfig verifichiamo che la nostra macchina si trovi all’indirizzo 192.168.0.5. Scopriamo il nostro gateway digitando:

route -n

route -n

Il risultato dovrebbe assomigliare a qualcosa di simile:

Tabella di routing IP del kernel
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.0.1     0.0.0.0         UG    0      0        0 enp0s3
192.168.0.0     0.0.0.0         255.255.255.0   U     0      0        0 enp0s3

Tabella di routing IP del kernel

Destination Gateway Genmask Flags Metric Ref Use Iface

0.0.0.0 192.168.0.1 0.0.0.0 UG 0 0 0 enp0s3

192.168.0.0 0.0.0.0 255.255.255.0 U 0 0 0 enp0s3

Il gateway è quindi 192.168.0.1, ricordiamoci che la nostra rete è stata impostata con netmask /24 ovvero 255.255.255.0

Impostiamo quindi tale indirizzo come indirizzo statico, usando le informazioni che abbiamo raccolto.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

Modifichiamo il file interfaces affinché abbia il seguente contenuto:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.5
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.5

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Faccio notare che per il DNS utilizziamo il DNS di Google all’indirizzo 8.8.8.8.

A questo punto riavviamo la scheda di rete digitando:

sudo ifdown enp0s3 && sudo ifup enp0s3

1	sudo ifdown enp0s3 && sudo ifup enp0s3

Faccio notare che la nostra interfaccia di rete è enp0s3, mentre in una classica configurazione fisica probabilmente sarebbe eth1.

Fatto questo modifichiamo il file hosts inserendo gli host stabiliti all’inizio:

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

Il file alla fine dovrebbe risultare qualcosa di simile a questo:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-manager

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-manager

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Salviamo il tutto, spegniamo la macchina (onde evitare conflitti, dal momento che sono tutte duplicate) e spostiamoci sul prossimo nodo.

Configurazione Ubuntu MySQL Nodo 1

Prima di procedere soffermiamoci un attimo a configurare le porte per l’inoltro sulla scheda di virtual box, ottenendo una configurazione simile a questa:

In questo modo collegandoci su porte diverse dell’interfaccia esterna potremo accedere, mediante SSH, alle specifiche macchine virtuali.

Una volta avviato il secondo nodo è molto probabile, essendo la prima macchina sull’indirizzo 192.168.0.5, che questo si trovi sull’indirizzo 192.168.0.6. Se facciamo tutto in questo ordine ci risparmiamo qualche piccolo lavoretto extra nella riassegnazione degli indirizzi. Colleghiamoci quindi al nostro nodo 1 (se usate Putty potete collegarvi al 192.168.56.1:23) e modifichiamo la scheda di rete con l’indirizzo statico, come abbiamo fatto prima.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

Il risultato sarà simile a questo:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.6
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.6

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Modifichiamo il file hosts:

sudo nano /etc/hosts

1	sudo nano /etc/hosts

Aggiungiamo le righe di prima:

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

E notiamo che abbiamo ancora ubuntu-mysql-manager come riferimento interno. Rinominiamolo in ubuntu-mysql-nodo1. Il file hosts alla fine risulterà così:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-nodo1

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-nodo1

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Infine modifichiamo il hostname digitando:

sudo nano /etc/hostname

1	sudo nano /etc/hostname

Anche qui dentro sostituiamo il nome di poco fa con quello nuovo, ovvero ubuntu-mysql-nodo1.

Fatto tutto questo spegniamo la macchina e passiamo al secondo nodo.

Configurazione Ubuntu MySQL Nodo 2

A questo punto dovrebbe essere tutto semplice, basta replicare quanto fatto per il nodo 1.

Il file /etc/network/interfaces avrà quindi il seguente aspetto:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.7
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.7

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Il file /etc/hosts apparirà così:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-nodo2

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-nodo2

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Mentre il file /etc/hostname conterrà una sola riga:

ubuntu-mysql-nodo2

1	ubuntu-mysql-nodo2

A questo punto anche il secondo nodo è pronto e possiamo spegnere la macchina.

4. Installazione del MySQL Cluster Manager

Adesso riavviamo il nostro cluster manager e avviamo l’installazione del software manager:

sudo apt-get install mysql-cluster-community-management-server

1	sudo apt-get install mysql-cluster-community-management-server

Una volta installato andiamo a creare la seguente cartella nella quale metteremo il file di configurazione:

sudo mkdir /var/lib/mysql-cluster

1	sudo mkdir /var/lib/mysql-cluster

Creiamo dentro un file chiamato config.ini:

sudo nano /var/lib/mysql-cluster/config.ini

1	sudo nano /var/lib/mysql-cluster/config.ini

A questo punto procediamo alla configurazione nel modo seguente:

[ndbd default]
# opzioni che interesseranno tutti i nodi
NoOfReplicas=2          # numero di repliche
DataMemory=80M          # quantità di memoria allocata per l'archivazione dei dati
IndexMemory=18M         # quantità di memoria allocata per l'indicizzazione dei dati
ServerPort=2202         # porta di connessione, non è necessario impostarla, la metto qui a titolo di esercizio

[ndb_mgmd]
# configurazione del manager
HostName=manager.mysql.cluster  # oppure ci possiamo mettere l'indirizzo ip, nel nostro caso sarebbe 192.168.0.5
DataDir=/var/lib/mysql-cluster  # cartella che conterrà i file LOG dei nodi

[ndbd]
# opzioni nodo 1
HostName=nodo1.mysql.cluster
NodeId=2
DataDir=/usr/local/mysql/data

[ndbd]
# opzioni nodo 2
HostName=nodo2.mysql.cluster
NodeId=3
DataDir=/usr/local/mysql/data

[mysqld]
#questa è la posizione dove si troverà il daemon del MySQL, il processo in esecuzione insomma
HostName=manager.mysql.cluster

[ndbd default]

# opzioni che interesseranno tutti i nodi

NoOfReplicas=2 # numero di repliche

DataMemory=80M # quantità di memoria allocata per l'archivazione dei dati

IndexMemory=18M # quantità di memoria allocata per l'indicizzazione dei dati

ServerPort=2202 # porta di connessione, non è necessario impostarla, la metto qui a titolo di esercizio

[ndb_mgmd]

# configurazione del manager

HostName=manager.mysql.cluster # oppure ci possiamo mettere l'indirizzo ip, nel nostro caso sarebbe 192.168.0.5

DataDir=/var/lib/mysql-cluster # cartella che conterrà i file LOG dei nodi

[ndbd]

# opzioni nodo 1

HostName=nodo1.mysql.cluster

NodeId=2

DataDir=/usr/local/mysql/data

[ndbd]

# opzioni nodo 2

HostName=nodo2.mysql.cluster

NodeId=3

DataDir=/usr/local/mysql/data

[mysqld]

#questa è la posizione dove si troverà il daemon del MySQL, il processo in esecuzione insomma

HostName=manager.mysql.cluster

Ho inserito i commenti ai singoli parametri nel file stesso in modo da rendere più agevole la consultazione. I parametri in cima non sono di per se necessari, ma li mettiamo a scopo didattico per tenere presente che eventualmente li potremo modificare in base alle nostre esigenze.

Per finire installiamo il mysql-server, dal momento che abbiamo detto che il daemon del MySQL si troverà sulla medesima macchina del menager. Digitiamo:

sudo apt-get install mysql-server

1	sudo apt-get install mysql-server

Fatto.

5. Configurazione dei nodi

Adesso avviamo i nostri due nodi e configuriamoli nella maniera seguente (io qui configurerò il primo nodo, la stessa cosa va fatta sul secondo).

Anzitutto installiamo il programma per ciascun nodo digitando:

sudo apt-get install mysql-cluster-community-data-node

1	sudo apt-get install mysql-cluster-community-data-node

Quindi digitiamo:

sudo nano /etc/mysql/my.cnf

1	sudo nano /etc/mysql/my.cnf

Dentro al file scriviamo:

[mysqld]
ndbcluster

[mysql_cluster]
ndb-connectstring=manager.mysql.cluster

[mysqld]

ndbcluster

[mysql_cluster]

ndb-connectstring=manager.mysql.cluster

In questo modo collegheremo il nodo al cluster, demandando la gestione del servizio al cluster medesimo.

6. Avvio del cluster

Ora che abbiamo configurato sia il manager che gli altri nodi possiamo procedere all’avvio del nostro cluster.

Spostiamoci sul manager e digitiamo:

sudo ndb_mgmd -f /var/lib/mysql-cluster/config.ini

1	sudo ndb_mgmd -f /var/lib/mysql-cluster/config.ini

Questo avvierà il cluster sul manager importando il file di configurazione. Affinché si avvii automaticamente ad ogni riavvio modifichiamo il file di avvio nel seguente modo.

Anzitutto abilitiamo i servizi locali digitando:

sudo systemctl enable rc-local.service

1	sudo systemctl enable rc-local.service

E modifichiamo il file:

sudo nano /etc/rc.local

1	sudo nano /etc/rc.local

Inserendo, prima di exit 0, il precedente comando (questo sarà l’aspetto complessivo del file):

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

ndb_mgmd -f /var/lib/mysql-cluster/config.ini
exit 0

#!/bin/sh -e

# rc.local

# This script is executed at the end of each multiuser runlevel.

# Make sure that the script will "exit 0" on success or any other

# value on error.

# In order to enable or disable this script just change the execution

# bits.

# By default this script does nothing.

ndb_mgmd -f /var/lib/mysql-cluster/config.ini

exit 0

Adesso spostiamoci sui singoli nodi e per ciascun nodo digitiamo:

sudo mkdir -p /usr/local/mysql/data

1	sudo mkdir -p /usr/local/mysql/data

In questo modo creeremo la cartella per l’allocazione dei dati necessaria al nodo (con il comando -p diciamo ad mkdir di creare l’intero percorso).

Dopodiché avviamo il nodo digitando:

sudo ndbd

sudo ndbd

Affinché anche tutto ciò parta all’avvio digitiamo:

sudo systemctl enable rc-local.service

1	sudo systemctl enable rc-local.service

E poi ancora:

sudo nano /etc/rc.local

1	sudo nano /etc/rc.local

Modifichiamo il file affinché appaia in questo modo:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

ndbd
exit 0

#!/bin/sh -e

# rc.local

# This script is executed at the end of each multiuser runlevel.

# Make sure that the script will "exit 0" on success or any other

# value on error.

# In order to enable or disable this script just change the execution

# bits.

# By default this script does nothing.

ndbd

exit 0

Riavviamo il tutto.

7. Verifichiamo il funzionamento del cluster

A questo punto possiamo verificare il funzionamento del cluster spostandoci sul nostro manager e digitando:

ndb_mgm

ndb_mgm

Entrando nel terminale del ndb_ngm digitiamo:

SHOW

SHOW

Quello che dovremmo vedere sarà qualcosa di simile a questo:

Se tutto è andato bene questo sarà il risultato. Qualora uno dei nodi non fosse raggiungibile, oppure non fosse possibile collegarsi al daemon ci verrebbe segnalato esplicitamente.

Per uscire dal manager è sufficiente digitare exit e premere invio.

Come ultima operazione proviamo a creare una tabella sul nostro cluster.

8. Creiamo una tabella sul cluster

Accediamo anzitutto al mysql digitando nel manager:

mysql -u root -p

1	mysql -u root -p

Questo ci permetterà di accedere con l’utente root del database e ci verrà chiesta la password a schermo.

Anche qui possiamo fare una seconda verifica di quello che ci è già noto:

Infatti se tutto è andato bene ci verrà dato il benvenuto con la versione del MySQL Cluster Community Server.

A questo punto creiamo il nostro database di prova digitando:

CREATE DATABASE cluster_test;

1	CREATE DATABASE cluster_test;

Inseriamo nel database cluster_test la nostra tabella di prova:

USE cluster_test;
CREATE TABLE cluster_test (nome VARCHAR(20), cognome VARCHAR(20)) ENGINE=ndbcluster;

1 2	USE cluster_test; CREATE TABLE cluster_test (nome VARCHAR(20), cognome VARCHAR(20)) ENGINE=ndbcluster;

ATTENZIONE! E’ molto importante che l’engine sia impostato su ndbcluster, affinché la tabella lavori e sia distribuita sul cluster.

Inseriamo dei valori di prova:

INSERT INTO cluster_test (nome,cognome) VALUES('mario','rossi');

1	INSERT INTO cluster_test (nome,cognome) VALUES('mario','rossi');

Adesso proviamo ad interrogare la tabella digitando:

SELECT * FROM cluster_test;

1	SELECT * FROM cluster_test;

Il risultato dovrebbe essere questo:

Fatto, abbiamo il nostro cluster perfettamente funzionante e pronto all’uso.

[ubuntu] Installare Google PageSpeed Insights su server Apache

Su PageSpeed Insights Google mette a disposizione un utile strumento per verificare la velocità del proprio sito web, assieme a diversi parametri di ottimizzazione. Inutile dire che si tratta anzitutto di uno strumento di panoramica, che ci consente di verificare determinate caratteristiche tecniche del sito, che non devono essere per forza tutte soddisfatte (a volte è semplicemente impossibile, come quando segnala tra i javascript da ottimizzare quelli di Google Analytics stesso).

Vediamo come installarlo sul nostro server (come al solito nell’esempio utilizzo un Ubuntu Server 16.04).

Anzitutto apriamo il terminale e scarichiamo il file di installazione:

wget https://dl-ssl.google.com/dl/linux/direct/mod-pagespeed-stable_current_amd64.deb

1	wget https://dl-ssl.google.com/dl/linux/direct/mod-pagespeed-stable_current_amd64.deb

Questo comando scaricherà un file mod-pagespeed-stable_current_amd64.deb nella cartella che abbiamo selezionato.

Installiamo il pacchetto con:

sudo dpkg -i mod-pagespeed-*.deb

1	sudo dpkg -i mod-pagespeed-*.deb

A questo punto eseguiamo il controllo di tutte le dipendenze dei pacchetti installati con:

apt-get -f install

1	apt-get -f install

Se tutto è andato a dovere riavviamo apache.

sudo service apache2 restart

1	sudo service apache2 restart

Per attivare PageSpeed sarà sufficiente aggiungere, nella configurazione del virtual host, oppure in un file .htaccess l’istruzione:

ModPagespeed on

1	ModPagespeed on

Maggiori informazioni sui parametri di configurazione si trovano sul sito ufficiale.

[windows server] Spostare la cartella dei file di aggiornamento di WSUS

Obiettivo: spostare la cartella di archiviazione degli aggiornamenti di WSUS in una nuova posizione

Tipicamente i file di aggiornamento gestiti dal server WSUS si trovano nella posizione C:\Comsys WSUS.

Per cambiare tale cartella è sufficiente trovare il programma wsusutil.exe ed effettuare lo spostamento nel modo in cui segue:

WIN+R per aprire ESEGUI e digitare CMD per aprire il prompt dei comandi
Spostarsi nella cartella di wsusutil.exe tipicamente dovrebbe trovarsi in C:\Program Files\Update Services\Tools
Digitare quindi CD C:\Program Files\Update Services\Tools
Creare quindi la nuova cartella di destinazione dei file di aggiornamento, per esempio su un disco F creando una cartella F:\WSUS
Digitare quindi wsusutil.exe movecontent F:\WSUS F:\move.log
Questo comando avvierà lo spostamento dei file dalla posizione attuale a quella nuova

[c#] Creare una classe base generica con tipo aperto

Immaginiamo di voler creare in C# una classe generica che possa gestire dei tipi aperti, un po’ come succede per le liste. Per esercizio vogliamo creare una classe chiamata Materie che accetti diverse classi come tipo di materia gestito, per esempio una classe Matematica. L’oggetto che vogliamo creare sarà di questo tipo:

Materie<Matematica> m = new Materie<Matematica>();

1	Materie<Matematica> m = new Materie<Matematica>();

A questo punto vogliamo avere un metodo per aggiungere dei voti per gli studenti della data materia, nel modo seguente:

m.addVoto(new Matematica("Mario",10));

1	m.addVoto(new Matematica("Mario",10));

E infine vogliamo poter estrarre, dal nostro oggetto m, una media dei voti, passandogli una funzione che si occuperà di definire il meccanismo di estrazione del voto dall’oggetto generico sul tipo aperto.

Per cui creiamo anzitutto la classe Matematica:

class Matematica
{
    public string corso;
    public int voto;

    public Matematica(string c, int v)
    {
        corso = c;
        voto = v;
    }
}

class Matematica

{

public string corso;

public int voto;

public Matematica(string c, int v)

{

corso = c;

voto = v;

}

E poi creiamo la classe Materie:

class Materie<T>
{
    List<T> voti = new List<T>();

    public void addVoto(T voto)
    {
        voti.Add(voto);
    }

    public double getMediaVoti(Func<T,double> funzioneMedia)
    {
        double media = 0;

        if( voti.Count > 0 )
        {

            foreach (T voto in voti)
            {
                media += funzioneMedia(voto);
            }

            media /= voti.Count;

        }

        return media;
    }
}

class Materie<T>

{

List<T> voti = new List<T>();

public void addVoto(T voto)

{

voti.Add(voto);

}

public double getMediaVoti(Func<T,double> funzioneMedia)

{

double media = 0;

if( voti.Count > 0 )

{

foreach (T voto in voti)

{

media += funzioneMedia(voto);

}

media /= voti.Count;

}

return media;

}

Faccio notare che il metodo getMediaVoti accetta come argomento un metodo generico che prenda che abbia come argomento il tipo aperto T e come restituzione un double (supponiamo che volendo calcolare dei voti essi dovranno essere comunque ricondotti a double).

Uniamo il tutto nel modo seguente:

class Program
{
    static void Main(string[] args)
    {
        Materie<Matematica> m = new Materie<Matematica>();

        m.addVoto(new Matematica("Mario",10));
        m.addVoto(new Matematica("Luigi", 8));
        m.addVoto(new Matematica("Luisa", 9));

        double media = m.getMediaVoti(calcolaMedia);

        Console.WriteLine("media {0}",media);
        Console.ReadLine();

    }

    static double calcolaMedia(Matematica m)
    {
        return m.voto;
    }
}

class Program

{

static void Main(string[] args)

{

Materie<Matematica> m = new Materie<Matematica>();

m.addVoto(new Matematica("Mario",10));

m.addVoto(new Matematica("Luigi", 8));

m.addVoto(new Matematica("Luisa", 9));

double media = m.getMediaVoti(calcolaMedia);

Console.WriteLine("media {0}",media);

Console.ReadLine();

}

static double calcolaMedia(Matematica m)

{

return m.voto;

}

In questo caso l’oggetto m si comporta in modo analogo ad una lista, permettendo l’aggiunta di n elementi del tipo T, nel nostro caso Matematica. Dal momento che noi non conosciamo i specifici parametri e metodi di T chiediamo, per calcolare la media, che ci venga passata una funzione a cui sarà delegata l’estrazione dei voti come double dall’oggetto aperto di tipo T, tale metodo è calcolaMedia che accetta come argomento un oggetto di tipo Matematica.