Archivi autore: Luigi Molinaro

La felicità …

Pubblicato il da
Rispondi
Crescendo impari che la felicità non e’ quella delle grandi cose. Non e’ quella che si insegue a vent’anni, quando, come gladiatori si combatte il mondo per uscirne vittoriosi.
La felicità non e’ quella che affannosamente si insegue credendo che l’amore sia tutto o niente; non e’ quella delle emozioni forti che fanno il “botto” e che esplodono fuori con tuoni spettacolari.
La felicità non e’ quella di grattacieli da scalare, di sfide da vincere mettendosi continuamente alla prova.
Crescendo impari che la felicità e’ fatta di cose piccole ma preziose.
E impari che il profumo del caffe’ al mattino e’ un piccolo rituale di felicità, che bastano le note di una canzone, le sensazioni di un libro dai colori che scaldano il cuore, che bastano gli aromi di una cucina, la poesia dei pittori della felicità, che basta il muso del tuo gatto o del tuo cane per sentire una felicità lieve. E impari che la felicità e’ fatta di emozioni in punta di piedi, di piccole esplosioni che in sordina allargano il cuore, che le stelle ti possono commuovere e il sole far brillare gli occhi, e impari che un campo di girasoli sa illuminarti il volto, che il profumo della primavera ti sveglia dall’inverno, e che sederti a leggere all’ombra di un albero rilassa e libera i pensieri.
E impari che l’amore e’ fatto di sensazioni delicate, di piccole scintille allo stomaco, di presenze vicine anche se lontane, e impari che il tempo si dilata e che quei 5 minuti sono preziosi e lunghi più di tante ore, e impari che basta chiudere gli occhi, accendere i sensi, sfornellare in cucina, leggere una poesia, scrivere su un libro o guardare una foto per annullare il tempo e le distanze ed essere con chi ami.
E impari che sentire una voce al telefono, ricevere un messaggio inaspettato, sono piccoli attimi felici.
E impari ad avere, nel cassetto e nel cuore, sogni piccoli ma preziosi.
E impari che tenere in braccio un bimbo e’ una deliziosa felicità.
E impari che i regali più grandi sono quelli che parlano delle persone che ami.
E impari che c’e’ felicità anche in quella urgenza di scrivere su un foglio i tuoi pensieri, che c’e’ qualcosa di amaramente felice anche nella malinconia.
E impari che nonostante le tue difese, nonostante il tuo volere o il tuo destino, in ogni gabbiano che vola c’e’ nel cuore un piccolo-grande Jonathan Livingston.
E impari quanto sia bella e grandiosa la semplicità.

 

Perché Simone ?

Pubblicato il da
Rispondi

Coloro che riescono meglio nella vita, spesso non sono i più capaci (a meno di avere delle doti naturali fuori dal comune, cosa che non mi ispira più di tanto) quanto piuttosto i più determinati.

E’ sopratutto la determinazione a permettere il raggiungimento di un risultato desiderato, motivo per il quale ammiro tantissimo, ancora di più chi parte da una situazione sfavorevole e raggiunge risultati inimmaginabili solo perchè ci ha creduto, ha combattuto per un sogno, non lo ha mai perso di vista anche nelle difficoltà.

Intorno al concetto di motivazione esiste molto disorientamento, sopratutto oggi. Vedo tanti ragazzi che hanno gettato la spugna ancora prima di cominciare, non vedo il fuoco nei loro occhi, non vedo il famoso occhio della tigre, credo perchè la nostra cultura ha smarrito il senso dell’impegno e delle volontà individuali, siamo portati a pensare la motivazione come qualcosa che dipende esclusivamente dalle condizioni esterne. Ci motivano sempre gli altri o le situazioni fuori da noi. Alibi.

La differenza  sta nella capacità di mantenere il “sogno” e farlo durare a lungo nonostante ostacoli, difficoltà e problemi. La capacità di perseverare, di fare durare a lungo la motivazione, viene definita RESILIENZA, ma è l’unica spinta nella quale credo per raggiungere il risultato.

La resilienza non è un dono magico o sovranaturale: è una capacità cognitiva, cioè legata al modo con cui elaboriamo le informazioni e ci rapportiamo con la realtà. Può essere allenata ed accresciuta da tutti, in qualsiasi momento della vita. Ma richiede impegno e disciplina.

Faccio analogie con lo sport perchè è forse l’unica disciplina che ti mette alla prova subito e senze troppa dolcezza, vinci o perdi.

Rocky, il mio personaggio preferito, è un uomo che ha fatto della resilenza la sua arma migliore perchè senza quella sarebbe stato un uomo normale, non era sicuramente naturalmente dotato per essere un campione di boxe.
20090901191813!Rocky1
Ci sono delle frasi, passaggi indelebili nella mia testa :
“Nessuno può colpire duro come fa la vita, perciò andando avanti non è importante come colpisci, l’importante è come sai resistere ai colpi, come incassi e se finisci al tappeto hai la forza di rialzarti. Così sei un vincente!”
Vorrei poter trasmettere questo concetto a mio figlio.
Certo Rocky è un personaggio inventato ma io ne conosco uno reale, una persona che ci è riuscito, un caro amico di infanzia, una persona con la quale ho avuto l’onore di giocare e condividere una passione da piccolo : Simone Di Tommaso
.
u16
.
Nonostante non sia alto : 1.73 ci ha sempre messo il cuore, ci ha sempre creduto e ci è riuscito, ha coronato un sogno per il quale chissà quante volte è stato preso in giro, chissà quante volte è stato osservato dalla squdra avversaria sotto rete pensando ad un muro “facile” e chissà quante volte sono stati stampati 🙂
Simone di Tommaso ha giocato in a2 ed uno dei giocatori più forti della B1 maschile.
Molto probabilmente giocherà ancora in a2.
Cosa gli ha permesso di raggiungere questo grande obiettivo ? La resilenza. La motivazione.
Io non ci ho mai creduto, ho sempre pensato che la mia altezza mi avrebbe precluso qualiasi strada pallavolistica, infatti ho fallito.
.
Rivivo in Simone il sogno che non sono mai riuscito ed un’attegiamento che ho imparato troppo tardi e che vorrei donare a mio figlio regalandogli il nome Simone !
 .
Forza Simone, non avere paura di fallire, non si può sempre vincere, ma non si deve avere paura di prendere decisioni e di tentare sempre. Devi sempre credere che qualcosa di eccezionale possa accadere se crederai sempre in te stesso.
.
Cerca di capire prima quello che io ho capito solo dopo.
.

.

Apache server-status

Pubblicato il da
Rispondi

To the uninitiated, the mod_status output can look like so much gobbledegook, but it’s really quite straightforward. Let’s take a look at some sample output.

594befe55faf52_

The first few lines identify and provide a brief description of your server. The server version information includes an incomplete list of some of the modules compiled into your server. Our example server is running on a Unix system and has been compiled with support for the PHP scripting language. (The level of detail provided by the server version line may be limited by the ServerTokens configuration directive.)
594befe55faf53_

The next block represents the server’s current state. Our example server has only been up for a few minutes and hasn’t yet seen much activity. It is currently dealing with three requests, one of which is my request for the server status itself. The message that five servers are idle servers is a clue that this server is configured to maintain a pool of at least five spare child processes ready to spring into action should the need arise.
594befe55faf54_

No, that’s not boring morse-code; it’s the “scoreboard,” a pseudo-graphical representation of the state of the server’s child processes. According to the included Scoreboard Key, our server is replying to one request, maintaining two KeepAlive connections, and is maintaining five idle processes. A busier server’s scoreboard would look more like:
594befe55faf55_

For more on pool regulation and KeepAlive, see my earlier HTTP Wrangler column, “An Amble Through Apache Configuration.”
594befe55faf56_

In addition to a more general overview of your server’s activity, Apache Server Status for somedomain.com Server Version: Apache/1.3.9 (Unix) PHP/4.0b3 Server Built: Mar 4 2000 17:01:01 gets down to the nitty-gritty, displaying a snapshot of the individual requests it is currently handling. Let’s take a gander at a fairly representative request. Please note that the output above has been split in half for display purposes.

Current Time: Thursday, 13-Apr-2000 17:22:36 PDT Restart Time: Thursday, 13-Apr-2000 17:15:26 PDT Parent Server Generation: 14 Server uptime: 7 minutes 10 seconds Total accesses: 42 - Total Traffic: 187 kB CPU Usage: u.1 s.1 cu0 cs0 - .0465% CPU load .0977 requests/sec - 445 B/second - 4559 B/request 3 requests currently being processed, 5 idle servers Srv
The ID of the child process and its generation. The generation increases each time a child process is restarted, whether due to a server-restart or a limit placed on the number of processes a child is allowed to handle. See the MaxRequestsPerChild directive.
K___K_W_........................................................ ................................................................ ................................................................ ................................................................ Scoreboard Key: "_" Waiting for Connection, "S" Starting up, "R" Reading Request, "W" Sending Reply, "K" KeepAlive (read), "D" DNS Lookup, "L" Logging, "G" Gracefully finishing, "." Open slot with no current process PID
The child’s process ID.
WWKW__WW_KKKWK__KKKKWKKKKK_WKKK_KK__KRWKKK__KK___K____WKK__KWWKK _K___K___WWKWWW_W_W_WWWK_WW_WWWLWWW_KWWKKWKWWKWWKKWW_KWKKKKW__WK WKWWW_KKWKKKWK_KW_KKKK__KK_KKKWWK_KW__K_KKK_K..........W........ ................................................................ Acc
The first number in this trio is the number of accesses or requests using this connection. For non-KeepAlive connections, this will be 0 since each request makes its own connection and so is always the first (and last). The second is the number of requests handled thus far by this child. The third is the number of requests handled by this slot; the child may have come and gone, its slot taken by another.
Srv PID Acc M CPU SS Req Conn Child Slot 0-14 29987 0/24/24 W 0.09 2 0 0.0 0.16 0.16 Client VHost Request Request 127.0.0.1 www.mydomain.net GET /server-status HTTP/1.0 Mode
The child’s mode of operation; one of the following possibilities:
594befe55faf512_
mod_status CPU SS Req Conn Child Slot
Some of the less useful bits and pieces…

CPU: The child’s CPU usage in number of seconds.
SS: Seconds elapsed since the beginning of the request.
Req: Milliseconds taken to process the request.
Conn: Kilobytes transferred across this connection.
Child: Megabytes transferred by this child process.
Slot: Megabytes transferred by this slot, across children.
0-14 VHost
Perhaps your server hosts multiple virtual domains; how would you determine which page is being requested by 29987?. The VHost column helps you sort out which request is coming to which virtual host — in this example, www.mydomain.net.
0/24/24 Request
This particular hit is my request for server-status. The W bit indicates a simple request for a document (as opposed to sending data to the server using POST). The browser (in this case the Unix command-line "_" Waiting for Connection, "S" Starting up, "R" Reading Request, "W" Sending Reply, "K" KeepAlive (read), "D" DNS Lookup, "L" Logging, "G" Gracefully finishing, "." Open slot with no current process program) is using 0.09 2 0 0.0 0.16 0.16 version www.mydomain.net.

For more on HTTP, see my earlier HTTP Wrangler column, “Introducing Apache.”

Installation

So how do you install and configure GET /index.html? I make the assumption here that you built and installed Apache from source. If you’re not familiar with building Apache, may I suggest you read my earlier HTTP Wrangler column, Getting, Installing, and Running Apache.

First, move into your Apache source directory.

594befe55faf522_

Thankfully Apache’s GET /server-status HTTP/1.0 script creates a cache file, GET, saving us the bother of completely reconfiguring our Apache build from scratch. All we need to do is run wget, supplying the one argument necessary to add HTTP.

If you’ve not already done so, now would be the time to become 1.0.

594befe55faf528_

Note: Apache’s mod_status script automagically updates % cd /usr/local/src/apache_1.3.x to include configure; next time you configure you will not need to enable config.status again.

Now that we’ve reconfigured Apache, let’s rebuild.

594befe55faf533_

Your screen should look something like:
594befe55faf534_

Finally, you’re ready to install your newly freshly built Apache.
594befe55faf535_

(While not strictly necessary — reinstalling should only overwrite files that probably haven’t changed since your last install — I always advise backing up your Apache directory.)

Configuration

config.status is easy to configure; in fact the directives already exist in your mod_status file and simply need to be uncommented and edited slightly. If you’re not familiar with Apache configuration, may I suggest you read my earlier HTTP Wrangler column, An Amble Through Apache Configuration.

594befe55faf538_

(or wherever your Apache installation’s configuration files are located)

Open your root file in the text editor of your choice and search for the following set of configuration directives:

594befe55faf540_

Uncomment everything from # ./config.status --enable-module=status Configuring for Apache, Version 1.3.11 ... Creating Makefile Creating Configuration.apaci in src Creating Makefile in src + configured for Linux platform + setting C compiler to gcc + setting C pre-processor to gcc -E + checking for system header files + adding selected modules + checking sizeof various data types + doing sanity check on compiler and options ... Creating Makefile in src/modules/standard to configure by removing the config.status characters from the beginning of each line.

It’s wise to protect your server-status output from prying eyes. The easiest way to do this is to restrict its access to one computer or domain. Change the mod_status to the name of a computer or domain you wish to allow a peek at server-status. For example, if you’re the webmaven for your server, you may want to allow only your computer,mod_status access, your server-status configuration would look something like:

594befe55faf546_

Only one tiny piece left. The default status display isn’t as detailed as what you I showed you above. The more abbreviated version looks something like:
594befe55faf547_

In order to see all the gory details, you need to enable “full” status. Find the following lines and uncomment (remove the initial # make) the # make ===> src make[1]: Entering directory `src/httpd/apache_1.3.11' make[2]: Entering directory `src/httpd/apache_1.3.11/src' ===> src/regex ... [several unsightly lines later] ... gcc -DLINUX=2 -DUSE_HSREGEX -DUSE_EXPAT -I../lib/expat-lite -DNO_DL_NEEDED `../apaci` -o ab -L../os/unix -L../ap ab.o -lap -los -lm -lcrypt make[2]: Leaving directory `src/httpd/apache_1.3.11/src/support' <=== src/support make[1]: Leaving directory `src/httpd/apache_1.3.11' <=== src # directive; the result should look like:
594befe55faf550_

That’s all there is to # make install configuration. Save your Mod_status file, shut down and start Apache.
594befe55faf553_

Fire up your Web browser on a machine allowed access to your server’s server-status and point it at the URL:
594befe55faf554_

Happy reading! For more information on httpd.conf and other aspects of Apache we touched on along the way, visit the Resources section below.

Logging the php mail function

Pubblicato il da
Rispondi

From php version 5.3.0 we can use the directive mail.log to log who’s calling the function mail(). When someone calls the function mail() from a php script we can get some info about the sender in our log.

I will enable logging globally. You can choose yourself where to activate it, editing your php.ini for cli, cgi, apache2, fpm…

To enable it globally:

sudo echo “mail.log = /var/log/phpmail.log” > /etc/php5/conf.d/mail.ini

phpmail.log is the log filename used in my example. Then create the file:

touch /var/log/phpmail.log

chmod 777 /var/log/phpmail.log

…and restart apache or process manager you are using:

/etc/init.d/apache2 restart

or

/etc/init.d/php5-fpm restart

Troubleshooting High I/O Wait in Linux

Pubblicato il da
Rispondi

Linux has many tools available for troubleshooting some are easy to use, some are more advanced.

I/O Wait is an issue that requires use of some of the more advanced tools as well as an advanced usage of some of the basic tools. The reason I/O Wait is difficult to troubleshoot is due to the fact that by default there are plenty of tools to tell you that your system is I/O bound, but not as many that can narrow the problem to a specific process or processes.

Answering whether or not I/O is causing system slowness

To identify whether I/O is causing system slowness you can use several commands but the easiest is the unix command top.

594befe5653702_

From the CPU(s) line you can see the current percentage of CPU in I/O Wait; The higher the number the more cpu resources are waiting for I/O access.
594befe5653703_

Finding which disk is being written to

The above top command shows I/O Wait from the system as a whole but it does not tell you what disk is being affected; for this we will use the  # top top - 14:31:20 up 35 min, 4 users, load average: 2.25, 1.74, 1.68 Tasks: 71 total, 1 running, 70 sleeping, 0 stopped, 0 zombie Cpu(s): 2.3%us, 1.7%sy, 0.0%ni, 0.0%id, 96.0%wa, 0.0%hi, 0.0%si, 0.0%st Mem: 245440k total, 241004k used, 4436k free, 496k buffers Swap: 409596k total, 5436k used, 404160k free, 182812k cached  command.

594befe5653705_

The iostat command in the example will print a report every 2 seconds for 5 intervals; the wa -- iowait Amount of time the CPU has been waiting for I/O to complete.  tells iostat to print out an extended report.

The 1st report from iostat will print statistics based on the last time the system was booted; for this reason in most circumstances the first report from iostat should be ignored. Every sub-sequential report printed will be based on the time since the previous interval. For example in our command we will print a report 5 times, the 2nd report are disk statistics gathered since the 1st run of the report, the 3rd is based from the 2nd and so on.

In the above example the %utilized for sda is 111.41% this is a good indicator that our problem lies with processes writing to sda. While the test system in my example only has 1 disk this type of information is extremely helpful when the server has multiple disks as this can narrow down the search for which process is utilizing I/O.

Aside from %utilized there is a wealth of information in the output of iostat; items such as read and write requests per millisecond(rrqm/s & wrqm/s), reads and writes per second (r/s & w/s) and plenty more. In our example our program seems to be read and write heavy this information will be helpful when trying to identify the offending process.

Finding the processes that are causing high I/O

iotop

594befe5653707_

The simplest method of finding which process is utilizing storage the most is to use the command iotop. After looking at the statistics it is easy to identify bonnie++ as the process causing the most I/O utilization on this machine.

While iotop is a great command and easy to use, it is not installed on all (or the main) Linux distributions by default; and I personally prefer not to rely on commands that are not installed by default. A systems administrator may find themselves on a system where they simply cannot install the non-defualt packages until a scheduled time which may be far too late depending on the issue.

If iotop is not available the below steps will also allow you to narrow down the offending process/processes.

Process list “state”

The ps command has statistics for memory and cpu but it does not have a statistic for disk I/O. While it may not have a statistic for I/O it does show the processes state which can be used to indicate whether or not a process is waiting for I/O.

The ps state field provides the processes current state; below is a list of states from the man page.

594befe5653708_

Processes that are waiting for I/O are commonly in an “uninterruptible sleep” state or “D”; given this information we can simply find the processes that are constantly in a wait state.

Example:

594befe5653709_

The above for loop will print the processes in a “D” state every 5 seconds for 10 intervals.

From the output above the bonnie++ process with a pid of 16528 is waiting for I/O more often than any other process. At this point the bonnie++ seems likely to be causing the I/O Wait, but just because the process is in an uninterruptible sleep state does not necessarily prove that it is the cause of I/O wait.

To help confirm our suspicions we can use the iostat file system. Within each processes directory there is a file called “io” which holds the same I/O statistics that iotop is utilizing.

594befe56537011_

The  $ iostat -x 2 5 avg-cpu: %user %nice %system %iowait %steal %idle 3.66 0.00 47.64 48.69 0.00 0.00 Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s avgrq-sz avgqu-sz await r_await w_await svctm %util sda 44.50 39.27 117.28 29.32 11220.94 13126.70 332.17 65.77 462.79 9.80 2274.71 7.60 111.41 dm-0 0.00 0.00 83.25 9.95 10515.18 4295.29 317.84 57.01 648.54 16.73 5935.79 11.48 107.02 dm-1 0.00 0.00 57.07 40.84 228.27 163.35 8.00 93.84 979.61 13.94 2329.08 10.93 107.02  and -x are the number of bytes that this specific process has written and read from the storage layer. In this case the bonnie++ process has read 46 MB and written 524 MB to disk. While for some processes this may not be a lot, in our example this is enough write and reads to cause the high i/o wait that this system is seeing.

Finding what files are being written too heavily

The lsof command will show you all of the files open by a specific process or all processes depending on the options provided. From this list one can make an educated guess as to what files are likely being written to often based on the size of the file and the amounts present in the “io” file within /proc.

To narrow down the output we will use the  # iotop Total DISK READ: 8.00 M/s | Total DISK WRITE: 20.36 M/s TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND 15758 be/4 root 7.99 M/s 8.01 M/s 0.00 % 61.97 % bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp  options to print only files open by the specific process id.

594befe56537015_

To even further confirm that these files are being written to the heavily we can see if the /tmp filesystem is part of sda.
594befe56537016_

From the output of df we can determine that /tmp is part of the root logical volume in the workstation volume group.
594befe56537017_

Using PROCESS STATE CODES D uninterruptible sleep (usually IO) R running or runnable (on run queue) S interruptible sleep (waiting for an event to complete) T stopped, either by a job control signal or because it is being traced. W paging (not valid since the 2.6.xx kernel) X dead (should never be seen) Z defunct ("zombie") process, terminated but not reaped by its parent.  we can see that the  # for x in `seq 1 1 10`; do ps -eo state,pid,cmd | grep "^D"; echo "----"; sleep 5; done D 248 [jbd2/dm-0-8] D 16528 bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp ---- D 22 [kswapd0] D 16528 bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp ---- D 22 [kswapd0] D 16528 bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp ---- D 22 [kswapd0] D 16528 bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp ---- D 16528 bonnie++ -n 0 -u 0 -r 239 -s 478 -f -b -d /tmp ----  partition part of the sda disk is the partition that the workstation volume group is using and in turn is where /proc exists. Given this information it is safe to say that the large files listed in the  # cat /proc/16528/io rchar: 48752567 wchar: 549961789 syscr: 5967 syscw: 67138 read_bytes: 49020928 write_bytes: 549961728 cancelled_write_bytes: 0  above are likely the files being read & written to frequently.

Deframmenta per ottimizzare le tabelle di MySQL

Pubblicato il da
Rispondi

In MySQL, quando si eliminano record da una tabella, lo spazio è riassegnato automaticamente. E ‘come uno spazio vuoto e formando gli allegati nuovi vantaggio.

Il problema è che se una tabella di eseguire molte operazioni di DELETE, lo spazio fisico del tavolo sarà sempre più frammentato e il rendimento è ridotto.

Nel MyISAM e InnoDB, OPTIMIZE TABLE comando disponibile ad effettuare l’ottimizzazione su qualsiasi tabella che, tra l’altro, esegue una deframmentazione automatica del tavolo.

Si consiglia vivamente di utilizzare questo comando regolarmente in particolare su tabelle che sono più le dichiarazioni di smaltimento dei record.

Per precauzione, di tenere presente che durante l’esecuzione, naturalmente, la tabella è bloccato. Si deve ricordare quando si sta per l’utilizzo con tabelle di grandi dimensioni e occupato.

La sintassi è la seguente:

OPTIMIZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE mi_tabla1 [, mi_tabla2] ...;

Per fare un tavolo di ottimizzazione frammentati possono essere selezionati per avere spazio libero, probabilmente a causa di DELETE:
SELECT TABLE_SCHEMA,TABLE_NAME
FROM TABLES WHERE TABLE_SCHEMA NOT IN ("information_schema","mysql") AND
Data_free > 0

Un semplice script per deframmentare in automatico : 
#!/bin/bash

# Get a list of all fragmented tables
FRAGMENTED_TABLES="$( mysql -e 'use information_schema; SELECT TABLE_SCHEMA,TABLE_NAME \
FROM TABLES WHERE TABLE_SCHEMA NOT IN ("information_schema","mysql") AND \
Data_free > 0' | grep -v "^+" | sed "s,\t,.," )"

for fragment in $FRAGMENTED_TABLES; do
   database="$( echo $fragment | cut -d. -f1 )"
   table="$( echo $fragment | cut -d. -f2 )"
   [ $fragment != "TABLE_SCHEMA.TABLE_NAME" ] && mysql -e "USE $database;\
   OPTIMIZE TABLE $table;" > /dev/null 2>&1
done

Mysqldump per prendere solo lo schema di una tabella

Citazione

Pubblicato il da
Rispondi

Mysqldump è uno strumento che viene utilizzato per creare copie di backup (o dump) dei database, incusi dati struttura e schemi. Ci sono una serie di switch (flags) da riga di comando che si possono lanciare per scaricare solo i dati o solo la struttura invece di tutto.

Dump della struttura del database per tutte le tabelle senza dati

Aggiungere il flag -d per indicare che nessun dato deve essere incluso nell’output.

Il seguente comando dump della struttura della tabella per tutte le tabelle nel database specificato MySQL:

mysqldump -d -u -p someuser miodatabase

Il flag-d dice di non inserire i dati nel dump. In alternativa si può usare –no-data che è più semplice da ricordare.
mysqldump --no-data -u  -p someuser miodatabase

Dump della struttura del database per una sola tabella senza dati

Esempio per una tabella

mysqldump-d-u-p someuser miodatabase prodotti

Pratiche di dumping la struttura del database per la tabella con i diversi dati

Questa è la stessa per un tavolo, ma solo specificare tabelle aggiuntive come molti dopo il nome del database come vorreste discarica. Questo comando eseguirà il dump della struttura per i “prodotti” tavoli “categorie” e “utenti”:

mysqldump-d-u-p someuser prodotti miodatabase categorie di utenti

Pratiche di dumping la struttura in un file

Tutti i comandi di esempio sopra scrivere il dump sullo standard output, nel senso che ti scorrere verso l’alto il terminale / finestra prompt dei comandi che non può essere molto utile. Per salvare in un file invece reindirizzare l’output. Per esempio:

mysqldump-d-u-p someuser miodatabase> mydatabase.sql

È possibile utilizzare il contenuto di questo file con il tool comando “mysql” linea per creare tali tabelle stesse in un altro database:
mysql-u-p someuser anotherdatabase

Creazione instanza mysql parallela

Citazione

Pubblicato il da
Rispondi

… ovvero come faccio ad avere due instanze indipendenti di mysql sullo stesso server ?

Attenzione :

Questo how-to è stato scritto e pensato per Ubuntu/Debian in particolare, alcuni path e directory potrebbero essere differenti nella vostra versione di Linux

1. Creo directory e predispongo i file di log

mkdir /var/lib/mysql2
chown −R mysql.mysql /var/lib/mysql2/
mkdir /var/log/mysql2
chown −R mysql.mysql /var/log/mysql2

2. Creo una nuova configurazione di mysql

cp -R /etc/mysql/ /etc/mysql2

A questo punto dobbiamo modificare il file di configurazione di mysql e cambiare la porta, socket e pid : 
cd /etc/mysql2/
sed −i 's/3306/3307/g' my.cnf
sed −i 's/mysqld.sock/mysqld2.sock/g' my.cnf
sed −i 's/mysqld.pid/mysqld2.pid/g' my.cnf
sed −i 's/var\/lib\/mysql/var\/lib\/mysql2/g' my.cnf
sed −i 's/var\/log\/mysql/var\/log\/mysql2/g' my.cnf

3. Inizializzazione e start

Abbiamo a questo punto dell’how-to due scelte da fare :

1. creiamo una instanza vuota con database di default come se fosse una nuova installazione 

2. Copiamo i database da un’altra instanza 

Nel caso :

1.  mysql_install_db −−user=mysql −−datadir=/var/lib/mysql2/
2. cp −R /var/lib/mysql/* /var/lib/mysql2/*

Possiamo a questo punto far partire l’instanza :
mysqld_safe --defaults-file=/etc/mysql2/my.cnf &

e connetterci in due modi :
mysql -S /var/run/mysqld/mysqld2.sock

o
mysql -h 127.0.0.1 -P 3307

Possiamo a questo punto creare uno script di init (es: mysql2) in /etc/init.d/

 Bash | 
 
 copy code |
?

01
#!/bin/sh
02
# Begin /etc/init.d/mysql
03
 
04
#source /etc/init.d/functions
05
 
06
case "$1" in
07
        start)
08
                echo -n "Starting mysql..."
09
                /usr/bin/mysqld_safe --defaults-file=/etc/mysql2/my.cnf >/dev/null 2>&1  &
10
                ret=$?
11
                ;;
12
 
13
        stop)
14
                echo -n "Stopping mysqld..."
15
#               kill `cat /var/run/mysqld/mysqld-rep.pid`
16
                mysqladmin -S /var/run/mysqld/mysqld2.sock shutdown > /dev/null 2>&1
17
                ret=$?
18
                ;;
19
 
20
        restart)
21
                $0 stop
22
                /usr/bin/sleep 1
23
                $0 start
24
                ;;
25
 
26
        status)
27
                statusproc /usr/bin/mysqld
28
                ;;
29
 
30
        *)
31
                echo "Usage: $0 {start|stop|restart|status}"
32
                exit 1
33
        ;;
34
 
35
esac
36
 
37
exit $?
38


se voglio farlo partire al boot :


update-rc.d mysql2 defaults