AutorZerial

Sistemas de ficheros: ext3 o XFS?

El escenario era el siguiente:
Servidor Intel Xeon con cuatro núcleos de 2Ghz cada uno, 8Gb de ram y un arreglo de discos SCSI en Raid5 (300Gb). La funcionalidad del servidor es ser un host de máquinas virtuales. El diléma era qué filesystem usar, estába entre ext3 y XFS entonces me puse a googlear y encontre varios benchmarks y comentarios interesante al respecto, donde se comparaban esos dos o más sistemas de ficheros. Mis necesidades eran encontrar un sistema de ficheros que sea rápido y que trabaje bien con ficheros de gran tamaño (>=1Gb).
Navegando y navegando, me encontré con un benchmark en el sitio debian-administrator que me ayudó en parte a decidir lo que debía hacer.
En dicho benchmark se analizaron los siguientes puntos:

* Operations on a large file (ISO image, 700MB) Copy ISO from a second disk to the test disk
* Recopy ISO in another location on the test disk
* Remove both copies of ISO

* Operations on a file tree (7500 files, 900 directories, 1.9GB) Copy file tree from a second disk to the test disk
* Recopy file tree in another location on the test disk
* Remove both copies of file tree

* Operations into the file tree List recursively all contents of the file tree and save it on the test disk
* Find files matching a specific wildcard into the file tree

* Operations on the file system Creation of the filesystem (mkfs) (all FS were created with default values)
* Mount filesystem
* Umount filesystem

Según ese artículo, el fs que mejor trabaja con ficheros de gran tamaño es xfs. Se hicieron dos tipos de pruebas, comparando jfs, xfs, ext3 y reiserfs. En la primera ganó xfs y ext3, en la segunda xfs y jfs.

The initial copy of the large file took longer on Ext3 (38.2 secs) and ReiserFS (41.8) when compared to JFS and XFS (35.1 and 34.8). The recopy on the same disk advantaged the XFS (33.1 secs), when compared to other FS (Ext3 = 37.3, JFS = 39.4, ReiserFS = 43.9). The ISO removal was about 100 times faster on JFS and XFS (0.02 sec for both), compared to 1.5 sec for ReiserFS and 2.5 sec for Ext3! All FS took comparable amounts of CPU to copy (between 46 and 51%) and to recopy ISO (between 38% to 50%). The ReiserFS used 49% of CPU to remove ISO, when other FS used about 10%. There was a clear trend of JFS to use less CPU than any other FS (about 5 to 10% less). The number of minor page faults was quite similar between FS (ranging from 600 – XFS to 661 – ReiserFS).
Conclusion : For quick operations on large files, choose JFS or XFS. If you need to minimize CPU usage, prefer JFS.
Operations on a file tree (7500 files, 900 directories, 1.9GB)
[…]
Conclusion : For quick operations on large file tree, choose Ext3 or XFS. Benchmarks from other authors have supported the use of ReiserFS for operations on large number of small files. However, the present results on a tree comprising thousands of files of various size (10KB to 5MB) suggest than Ext3 or XFS may be more appropriate for real-world file server operations. Even if JFS minimize CPU usage, it should be noted that this FS comes with significantly higher latency for large file tree operations.

Todo indicaba que debia usar XFS, pero la realidad era otra.
Seguir leyendo

Cambio de servidor

He cambiado el blog de servidor, se que es algo irrelevante, pero igual se los comento. Antes estaba alojado bajo el gentil auspicio del padre de Pons, quien tenia un servidor donde alojaba sitios de su empresa y donde yo, humildemente, tenia mi blog. Por varias razones decidi comprar un VPS, uno que este dentro de mi alcance, no es tan poderoso pero cumple con mis requerimientos. Tiene 18Gb de disco duro y 540Mb de ram, lo usaré para alojar este blog y otros proyectos que tengo en mente.

El servidor lo compré por recomendación de vostorga en Linode. Espero que me sirva.

Eso.

Script en perl en forma de camello

Ahora que me estoy especializando en perl, me acordé haber visto en el blog de vostorga un post bien curioso, escrito en perl y en forma de camello.


                                                       #
                                                   sub j(\$){($
                     P,$V)=                      @_;while($$P=~s:^
                 ([()])::x){                    $V+=('('eq$1)?-32:31
           }$V+=ord(  substr(                 $$P,0,1,""))-74} sub a{
          my($I,$K,$  J,$L)=@_               ;$I=int($I*$M/$Z);$K=int(
         $K*$M/$Z);$J=int($J*$M             /$Z);$L=int($L*$M/$Z); $G=$
         J-$I;$F=$L-$K;$E=(abs($          G)>=abs($F))?$G:$F;($E<0) and($
          I,$K)=($J,$L);$E||=.01       ;for($i=0;$i< =abs$E;$i++ ){ $D->{$K
                  +int($i*$F/$E)      }->{$I+int($i*$G/$E)}=1}}sub p{$D={};$
                 Z=$z||.01;map{    $H=$_;$I=$N=j$H;$K=$O=j$H;while($H){$q=ord
                substr($H,0,1,"" );if(42==$q){$J=j$H;$L=j$H}else{$q-=43;$L =$q
              %9;$J=($q-$L)/9;$L=$q-9*$J-4;$J-=4}$J+=$I;$L+=$K;a($I,$K,$J,$ L);
              ($I,$K)=($J,$L)}a($I,$K,$N,$O)}@_;my$T;map{$y=$_;map{ $T.=$D->{$y}
              ->{$_}?$\:' '}(-59..59);$T.="\n"}(-23..23);print"\e[H$T"}$w= eval{
              require Win32::Console::ANSI};$b=$w?'1;7;':"";($j,$u,$s,$t,$a,$n,$o
              ,$h,$c,$k,$p,$e,$r,$l,$C)=split/}/,'Tw*JSK8IAg*PJ[*J@wR}*JR]*QJ[*J'.
               'BA*JQK8I*JC}KUz]BAIJT]*QJ[R?-R[e]\RI'.'}Tn*JQ]wRAI*JDnR8QAU}wT8KT'.
               ']n*JEI*EJR*QJ]*JR*DJ@IQ[}*JSe*JD[n]*JPe*'.'JBI/KI}T8@?PcdnfgVCBRcP'.
                '?ABKV]]}*JWe*JD[n]*JPe*JC?8B*JE};Vq*OJQ/IP['.'wQ}*JWeOe{n*EERk8;'.
                  'J*JC}/U*OJd[OI@*BJ*JXn*J>w]U}CWq*OJc8KJ?O[e]U/T*QJP?}*JSe*JCnTe'.
                   'QIAKJR}*JV]wRAI*J?}T]*RJcJI[\]3;U]Uq*PM[wV]W]WCT*DM*SJ'.  'ZP[Z'.
                      'PZa[\]UKVgogK9K*QJ[\]n[RI@*EH@IddR[Q[]T]T]T3o[dk*JE'.  '[Z\U'.
                        '{T]*JPKTKK]*OJ[QIO[PIQIO[[gUKU\k*JE+J+J5R5AI*EJ00'.  'BCB*'.
                             'DMKKJIR[Q+*EJ0*EK';sub h{$\ = qw(% & @ x)[int    rand
                              4];map{printf  "\e[$b;%dm",int(rand 6)+101-60*   ($w
                               ||0);system(  "cls")if$w ;($A,$S)=    ($_[1],   $
                                _[0]);($M,   @,)= split  '}';for(     $z=256
                                ;$z>0; $z   -=$S){$S*=   $A;p @,}      sleep$_
                                [2];while   ($_[3]&&($    z+=$ S)       < =256){
                                p@,}}("".   "32}7D$j"     ."}AG".       "$u}OG"
                                ."$s}WG"    ."$t",""      ."24}("        ."IJ$a"
                                ."}1G$n"    ."}CO$o"     ."}GG$t"        ."}QC"
                                 ."$h}"      ."^G$e"    ."})IG"          ."$r",
                                 "32}?"       ."H$p}FG$e}QG$r".          "}ZC"
                                 ."$l",          "28}(LC" .""            ."".
                                 "$h}:"           ."J$a}EG".             "$c"
                                 ."}M"             ."C$k}ZG".            "$e"
                                 ."}"             ."dG$r","18"          ."}("
                                ."D;"            ."$C"  )}{h(16         ,1,1,0
                               );h(8,          .98,0,0   );h(16         ,1,1,1)
                               ;h(8.0         ,0.98,0,     1);         redo}###
                             #written                                 060204 by
                           #liverpole                                  @@@@@@@
                        #@@@@@@@@@@@

Para ejecutarlo basta que lo copies y lo pegues en tu editor de texto favorito y lo ejecutes escribiendo perl script.pl. Tambien puedes descargarlo desde acá.

Tunear MySQL o cómo aumentar el rendimiento de tu servidor

Buscando como mejorar el rendimiento de un servidor mysql encontre un script en perl que realiza una serie de pruebas en nuestras bases de datos y finalmente nos muestra un resultado de esos test de memoria, consulta, “velocidad”, rendimiento, etc. Y nos da algunos tips para poder mejorar la configuracion del mysql y llegar a un rendimiento mas optimo.

Caracteristicas del mysqltuner:

* Memory Usage: Calculates MySQL memory usage at max load and makes recommendations for increasing or decreasing the MySQL memory footprint. Per-thread and server-wide buffer data is calculated
separately for an accurate snapshot of the server?s configuration.
* Slow Queries: Reviews the amount of slow queries relative to the total queries. Slow query time limits are also analyzed and recommendations are made.
* Connections: Current and historical connection counts are reviewed.
* Key Buffer: Takes configuration data and compares it to the actual indexes found in MyISAM tables. Key cache hit rates are calculated and variable adjustments are suggested.
* Query Cache: Query cache hit rates and usage percentages are used to make recommendations for the query cache configuration variables.
* Sorting & Joins: Per-thread buffers that affect sorts and joins are reviewed along with the statistics from the queries run against the server.
* Temporary Tables: Variable recommendations are made to reduce temporary tables that are written to the disk.
* Table Cache: Compares total tables opened to the currently open tables. Calculates the table cache hit rate in order to make suggestions.
* Open Files: Determines if the server will approach or run into the open file limit set by the operating system or the MySQL server itself.
* Table Locks: Finds table locking that forces queries to wait and makes suggestions for reducing locks that require a wait.
* Thread Cache: Calculates how many times MySQL must create a new thread to respond to a query.
* Aborted Connections: Finds applications that are not closing connections to MySQL properly.
* Read/Write Ratios: Calculates the percentage of read and write operations on your MySQL installation.

Seguir leyendo

Pidgin+(msn-pecan)+WLM = FAIL!

Hace un par de días Pidgin dejó de conectarse usando el procolo MSN, de un momento a otro. Probe conectandome desde emesene y tampoco conectó, no me quedó otra que conectarme usando algun cliente por web y decidí usar meebo, no tuve problemas. Más adelante, un tipo me dió una solución vía twitter, hablaba sobre un tal msn-pecan que, supuestamente, me iba a solucionar mi problema.
Ahora comienzan los problemas, cuando inicie sesion con ese tal msn-pecan, en la lista aparecieron menos de la mitad de los contactos que tenia y luego, cuando logre conectarme por emesene, me di cuenta que si, habian desaparecido mas de la mitad de mis contactos, no lo creí y me volví a conectar por meebo y si! desaparecieron mis contactos! Luego de putear un buen rato a ese msn-pecan, intente conectarme otra vez usando el protocolo msn tradicional de pidgin y este fue el resultado:


pidgin_fail

Cuando comienzo a poner “yes yes yes” a esos mensajitos pidgin se cierra y no me vuelve a agregar a mis contactos. Curiosamente, deje pasar 2 o 3 dias y esto se soluciono por arte de magia, volvi a entrar a pidgin (pensé: mm probaré a ver si por esas casualidades se arregló) e intente conectarme, paso lo mismo, pero esta vez, cuando fui presionando “yes yes” pidgin no se cayo, asi que esta historia tiene un final no tan triste ni tan feliz: Logre recuperar muchos contactos.

Moraleja: No usar MSN.

DomainKeys (DK) y DomainKeys Identified Mail (DKIM)

DomainKeys (DK) y DomainKeys Identified Mail (DKIM) son métodos de valicación de correo electrónico que permiten validar y firmar, mediante firma digital (clave pública y clave privada), los correos entrantes y salientes de nuestro servidor de correos. Esto permite que un dominio sea responsable por los correos que se envien a través de el para asegurarse que lleguen al inbox o que, de lo contrario, lleguen directo al junk.
Para validar la autenticidad de un remitente existen varias formas a nivel de dominio (dns) como es el SPF, Sender-ID, DK y DKIM.

Este último tiempo he estado trabajando con postfix validando los correos salientes para llegar al inbox de los servidores de correo más populares como Gmail, Yahoo! y Hotmail (msn, live, etc).
Estuve analizando las especificaciones RFC de cada protocolo (RFC4870 – DK; RFC4871 – DKIM), probandolas e implementandolas, llegando a distintas conclusiones. Básicamente, el diagrama de funcionalidad es el siguiente:

dk_graph

Seguir leyendo