Diseño, Desarrollo Web PHP, Recursos Virtuales, WiMarBueno: marzo 2014

martes, 11 de marzo de 2014

Conexión remota a MySQL en Ubuntu / Debian

El acceso remoto a un servidor MySQL está desactivado por defecto, para poder acceder desde otras máquinas, ya bien desde nuestra red local, o desde una dirección IP externa, debemos modificar algunas opciones de configuración:

En el fichero /etc/mysql/my.conf se deben comentar estas dos líneas

#skip-networking (esto no encontré en configuración, en otros tutoriales hablaban de esto)
#bind-address = 127.0.0.1

Después, se debe reiniciar el servidor MySQL
root@wimarbueno:/etc/mysql# service mysql restart

Y entonces, nos conectamos a mysql en el servidor y asignamos los siguientes privilegios:

vi que esto es para ip local, pero si tienes internet coge otro ip
GRANT ALL PRIVILEGES ON *.* TO root@"192.168.1.%" identified by "password";

esto para internet cualquier ip
GRANT ALL PRIVILEGES ON *.* TO root@"%.%.%.%" identified by "password";

Donde usuario y password son los datos de conexión que utilizaremos para conectarnos en remoto y 192.168.1.% indica que todas las direcciones IP de nuestra red local tienen acceso, % se usa como comodín.

De esta forma todas las direcciones IP de nuestra red local podrán conectarse en remoto a través de usuario / password:

mysql --user=root --host=servidor -p password

jueves, 6 de marzo de 2014

Solución a los problemas de compatibilidad con HTML5 de IE8 y Firefox 3

Se puede descargar el Js de Google en: http://code.google.com/p/html5shim/

1.- Agregan un condicional HTML para incluir un código JavaScript que sólo interpretarán las versiones anteriores a Internet Explorer 9:

<!--[if lt IE 9]>
    <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->

2.- Obligar a Internet Explorer que muestre las nuevas etiquetas HTML5 como bloques, ya que no las interpreta como tal y ahí reside parte del problema.

article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section, main{
    display: block;
}

Esto deberemos insertarlo al principio de nuestra hoja de estilos.
Con esto nuestro sitio HTML5 se verá perfectamente en todos los navegadores*.

*Probado en Internet Explorer 7 y 8. (falta agregar más datos...)

Abrir cmd de Windows en pantalla entera

Abrir una ventana DOS con privilegios de administrador.
Escribe en la linea de comandos esto: wmic y dale enter.
Clic en el botón Maximizar la ventana de la ventana DOS.
Escriba exit y luego dale a enter.
Clic en la barra símbolo del sistema y vas a Propiedades.
Sin cambiar nada, clic en el botón Aceptar para cerrar el cuadro de diálogo Propiedades del símbolo del sistema.
Escribe exit y presiona enter para cerrar la ventana DOS.
Ahora, vuelve a abrir la ventana DOS de nuevo con privilegios de administrador (como en el paso 1), debe tener de forma automática y totalmente maximizada para adaptarse a la resolución de tu escritorio.

Quedaria como imagen de abajo:

miércoles, 5 de marzo de 2014

Cómo instalar una interfaz gráfica en Ubuntu Server 12.04 LTS

Antes de ponerte a instalar ejecutar los siguientes comandos:

    sudo apt-get update                                     
    sudo apt-get upgrade

Aviso:
Si deseas que tu equipo consuma menor recurso es recomendable utilizar un gestor de ventanas más ligero que Gnome: Gnome es un gestor de ventanas bastante pesado, esto lo notaremos sobre todo en ordenadores algo antiguos, en los que es conveniente utilizar un gestor de ventanas ligero como puede ser Xfce (Xubuntu viene con Xfce).
Si quieren instalar un entorno gráfico en Ubuntu Server con todas las aplicaciones usen estas claves dependiendo del entorno gráfico que quieran instalar: (es ilógico utilizar esta instalación ya que ahorraríamos tiempo utilizando la versión desktop, pero la pongo por que se puede hacer).

Si quieren instalar GNOME, tecleen esto en Ubuntu Server:

            sudo apt-get install ubuntu-desktop

Si quieren instalar KDE, tecleen esto en Ubuntu Server:

            sudo apt-get install kubuntu-desktop

Si quieren instalar Xfce, tecleen esto en Ubuntu Server:

                    
            sudo apt-get install xubuntu-desktop

Recomendable:
Si no desean instalar todas las aplicaciones (seria lo normal para optimizar el sistema) que utiliza Ubuntu como: oppenoffice, juegos y demás aplicaciones…
Paso 1. Instalar gnome básico.
Tecleen en Ubuntu Server esto para instalar GNOME con los programas básicos.

                                        
    sudo apt-get install x-window-system-core gnome-core

AVISO: Si usan Ubuntu Server 8.04 deben teclear esto.

                                        
    sudo apt-get install xorg gnome-core

Paso 2. Ejecutar el entorno gráfico.
Después de instalarlo, tecleen esto en Ubuntu Server.

                                        
    startx

Y ya tenéis el escritorio mínimo. Lo que os ha instalado ha sido los “Accesorios” (básicos).
Paso 3. Instalar el idioma español.
Pero como es una instalación mínima, el idioma por defecto es el inglés. Para pasarlo a español, abre la Terminal y teclea cada código individualmente.

                                                    
    sudo apt-get install language-pack-es             
    sudo apt-get install language-pack-es-base                 
    sudo apt-get install language-pack-gnome-es                     
    sudo apt-get install language-pack-gnome-es-base                         
    sudo apt-get install language-selector                             
    sudo apt-get install language-support-es

Paso 4. Instalar GKSU.
Después de haber ejecutado todo eso, deben instalar gksu para que funcionen correctamente los menús.

                                                    
    sudo apt-get install gksu

Paso 5. Instalar las herramientas de red.

                                                                
    sudo apt-get install gnome-system-tools gnome-nettool

Modo Texto por defecto
Una vez instalado el modo gráfico, podemos dejar por defecto el modo texto haciendo lo siguiente:
1. Editamos /etc/default/grub
2. Buscamos la línea GRUB_CMDLINE_LINUX_DEFAULT=”" y la cambiamos por GRUB_CMDLINE_LINUX_DEFAULT=”text”
3. Registramos lo cambios realizados

                                                                
    sudo update-grub

4. Reiniciamos

                                                                            
    sudo reboot

Una vez arrancado en modo texto, podemos iniciar el modo gráfico usando startx

Fuente: http://www.profesorweb.es/2013/01/11/como-instalar-una-interfaz-grafica-en-ubuntu-server-12-04-lts/

martes, 4 de marzo de 2014

Los 25 mejores comandos/trucos SSH

Aquí pongo trucos de comandos.

Copiar una clave SSH a un host para que permita logins SSH sin password:
```
ssh-copy-id user@host
```
Con el comando ssh-keygen podemos generar las claves.
Iniciar un túnel SSH desde el puerto 80 de un host remoto al puerto 2001 de nuestra máquina local:
ssh –N –L2001:localhost:80 host_remoto

Ahora puedes acceder al sitio web remoto desde http://localhost:2001/
Enviar el sonido del micrófono local a los altavoces de un host remoto:
dd if=/dev/dsp | ssh –c arcfour –C user@host dd of=/dev/dsp

Esto enviará el sonido del puerto del micrófono como salida al puerto de los altavoces del equipo objetivo por SSH. La calidad del sonido es muy mala, por lo que se escuchará con mucho ruido de fondo.
Comparar un archivo remoto con uno local:
```
ssh user@host cat /ruta/del/archive_remoto | diff /ruta/del/archive_local
```
Útil para comprobar si un archivo local y otro remoto tienen diferencias.
Montar carpeta/sistema de ficheros por medio de SSH:
```
sshfs name@server:/ruta/de/carpeta /ruta/de/punto/de/montaje
```
Es necesario instalar SSHFS.

Con esto podremos montar una carpeta por red de forma segura
Conexión SSH por medio de “host in the middle”:
```
ssh –t host_alcanzable ssh host_inalcanzable
```
El host inalcanzable no está disponible desde la red local pero si es alcanzable desde la red del host alcanzable. Este comando crea una conexión al host inalcanzable por medio de una conexión oculta desde el host alcanzable.
Copiar desde host1 a host2 desde tu host:
```
ssh root@host1 “cd /directorio/a/copiar/ && tar –cf -.” | ssh root@host2 “cd /directorio/destino/de/copia/ && tar –xf –“
```
Útil si solo tú tienes acceso a host1 y host2 pero ellos no tienen acceso a tu host (por lo que ncat no funciona) y no tienen acceso entre ellos.
Correr cualquier aplicación GUI remotamente:
```
ssh –fX user@host [aplicación]
```
La configuración del server SSH requiere:

X11 Forwarding yes #por defecto en Debian

Compression delayed #configuración conveniente
Crear una conexión persistente a una máquina:
```
ssh -MNf user@host
```
Crear una conexión SSH persistente a un host en background. Combinar con tu configuración SSH en ~/.ssh/config:

Host host

ControlPath ~/.ssh/master-%r@%h:%p

ControlMaster no

Todas las conexiones SSH a la máquina irán por el socket SSH persistente. Esto es muy útil si usas SSH para sincronizar archivos (con rsync, sftp, cvs, svn…) de forma regular ya que no se crearán nuevos sockets cada vez que se abra una conexión SSH.
Adjuntar la pantalla por SSH:
```
ssh –t remote_host screen –r
```
Directamente adjunta la pantalla de una sesión remota (guarda un proceso bash padre inútil).
Llamar a puertos (port knocking):
```
knock [host] 3000 4000 5000 && ssh –p [port] user@host && knock [host] 5000 4000 3000
```
Llama a los puertos 3000 4000 5000 para abrir el puerto de un servicio (ssh por ejemplo) y vuelve a llamar a los puertos 5000 4000 3000 para cerrar el acceso al dicho servicio. Para esto es necesario tener instalado knockd.

Un ejemplo de configuración del servicio knockd mediante el archivo knockd.conf para que interpretase las llamadas anteriores sería:

[options]

Logfile = /var/log/knockd.log

[openSSH]

sequence = 3000,4000,5000

command = /sbin/iptables –A input –i eth0 –s %IP% -p tcp –dport 22 –j accept

tcpflags = syn

[closeSSH]

sequence = 5000,4000,3000

seq_timeout = 5

command = /sbin/iptables –D input –i eth0 –s %IP% -p tcp –dport 22 –j accept

tcpflags = syn
Eliminar una línea de un fichero de texto. Muy útil para solucionar ssh host key warnings (ver alternativas):
```
ssh-keygen -R [host_objetivo]
```
En este caso es mejor usar una herramienta dedicada.
Ejecutar comandos de consola remotos por SSH sin comillas de escape:
```
ssh host -l user $(<cmd.txt)
```
Método mas simple y mas portable:
```
ssh host -l user “`cat cmd.txt`”
```
Copiar una base de datos MySQL a un nuevo servidor vía SSH con un comando:
```
mysqldump –add-drop-table –extended-insert –force –log-error=error.log -uUSER -pPASS OLD_DB_NAME | ssh -C user@newhost “mysql -uUSER -pPASS NEW_DB_NAME”
```
Volcar una base de datos MySQL por un túnel SSH comprimido y usarlo como entrada a MySQL. Parece ser la forma más rápida de migrar una base de datos a un nuevo server.
Eliminar una línea de un fichero de texto. Útil para corregir warnings tipo “ssh host key change“:
```
sed -i 8d ~/.ssh/known_hosts
```
Copiar nuestra clave pública SSH a un servidor desde una máquina que no tenga ssh-copy-id:
```
cat ~/.ssh/id_rsa.pub | ssh user@machine “mkdir ~/.ssh; cat >> ~/.ssh/authorized_keys”
```
Si usas Mac OS X o cualquier otra variante *nix que no venga con ssh-copy-id esta línea te será útil para añadir tu clave pública a una maquina remota para poder así acceder a ella por SSH sin usar password.
Nota: En el grupo “Debian Administrator” de Linkedin hay un debate muy interesante acerca de este comando.
Test de rendimiento del canal SSH en tiempo real:
```
yes | pv | ssh $host "cat > /dev/null"
```
Conecta a un host vía SSH y muestra la velocidad de transferencia en tiempo real enviando todos los datos transferidos a /dev/null
Necesita tener pv (pipe viewer) instalado.
Debian:
```
apt-get install pv
```
Fedora:
```
yum install pv
```
(necesita tener habilitados los repositorios ‘extras’)
Como establecer una sesión remota con GNU screen a la que puedas reconectar:
```
ssh -t user@some.domain.com /usr/bin/screen -xRR
```
Mucho antes de que existieran las terminales etiquetadas la gente solía usar GNU screen para abrir varias consolas en una única terminal de texto. Esto combinado con SSH nos da la posibilidad de tener abiertas varias consolas usando una única conexión remota con las opciones de arriba. Si se separa con “Ctrl-a d” o si la sesión SSH se termina de forma accidental, todos los procesos que corren en las consolas remotas permanecen ininterrumpidos y preparados para poder reconectar. Otro comando de screen útil son “Ctrl-a d” (abrir nueva consola) y “Ctrl-a a” (alternar entre consolas). Se recomienda la lectura de esta guía rápida para más comandos screen.

Reanudar SCP (secure copy) de un fichero grande:

rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file

Puede reanudar una copia segura hecha con SCP que haya fallado usando rsync, muy útil cuando se transfieren grandes archivos como volcados de bases de datos por VPN
Requiere tener instalado rsync en ambos hosts.

rsync –partial –progress –rsh=ssh $file_source $user@$host:$destination_file local -> remote

rsync –partial –progress –rsh=ssh $user@$host:$remote_file $destination_file remote -> local

Analizar tráfico de forma remota por SSH con Wireshark:
```
ssh root@server.com ‘tshark -f “port !22″ -w -’ | wireshark -k -i -
```
Este comando captura el tráfico en una máquina remota con tshark, envía los datos pcap raw caturados por el canal SSH y los muestra en Wireshark. Pulsando Ctrl-c se para la captura y desafortunadamente se cierra la ventana de Wireshark. Esta conducta se puede arreglar pasándole -c # a tshark para que solo capture un # número de paquetes o también redireccionando los datos por un canal determinado distinto al SSH en vez de devolverlos a Wireshark por el mismo canal SSH. Se recomienda filtrar todo lo posible en el comando tshark para conservar el ancho de banda. También se puede reemplazar tshark por tcpdump asi:
```
ssh root@example.com tcpdump -w – ‘port !22′ | wireshark -k -i -
```
Mantener abierta una sesión SSH para siempre:
```
autossh -M50000 -t server.example.com ‘screen -raAd mysession’
```
Se abre una sesión SSH que permanece abierta indefinidamente. Muy útil para dispositivos portátiles que usen conexión WIFI en los que se pueden producir cortes de conectividad o cambios de spot WIFI.
Clientes SSH más rápidos, más duros y más fuertes:
```
ssh -4 -C -c blowfish-cbc
```
Forzamos IPv4, compresión del flujo y especificamos que Blowfish sea el algoritmo de cifrado del flujo de datos. Se supone que también se puede usar aes256-ctr como especificación de cifrado. También se omiten temas como control de sesiones master y otros temas que no estarán disponibles en la consola aunque esto hará que la velocidad del canal también mejore.
Acelerador de ancho de banda con cstream:
```
tar -cj /backup | cstream -t 777k | ssh host ‘tar -xj -C /backup’
```
El comando comprime en bzip una carpeta y la transmite al host por la red a 777Kbit/s. cstream puede hacer mucho más, ver http://www.cons.org/cracauer/cstream.html#usage
Por ejemplo:
```
echo w00t, i’m 733+ | cstream -b1 -t2
```
Transferir la clave pública SSH a otra máquina en un solo paso:
```
ssh-keygen; ssh-copy-id user@host; ssh user@host
```
Esta secuencia permite la configuración simple de logins SSH sin contraseña. Cuidado ya que si ya se tiene un par de claves SSH en el directorio ~/.ssh de la maquina local es posible que ssh-keygen la sobrescriba. ssh-copy-id copia la clave pública a la máquina remota y la añade como clave autorizada en el archivo remoto ~/.ssh/authorized_keys. Cuando se prueba la conexión SSH, si no se ha usado contraseña en la generación de la clave, la consola remota aparece en cuanto se invoca con SSH user@host.
Copiar la entrada estándar stdin al buffer X11:
```
ssh user@host cat /path/to/some/file | xclip
```
¿Alguna vez has tenido que hacer copia de forma segura (SCP) de un archivo a tu maquina local de trabajo para copiar su contenido a un mail? xclip puede ayudarte a hacerlo. Copia su salida estándar stdin al buffer X11 para que lo único que tengas que hacer sea click para copiar el contenido de ese gran fichero.

Espero que sean de utilidad y que se comenten resultados, mas comandos útiles y posibles adaptaciones o problemas.

Fuente: http://www.openredes.com/2011/09/23/los-25-mejores-comandos-trucos-ssh/

Páginas