Seguridad informática, el eslabón débil

Seguridad informática, el eslabón débil

La seguridad informática a pasado de ser una término reservado para informáticos, a ser algo muy importante en nuestro día, ya sea para un uso particular o para un uso empresarial cada vez es más importante tener claro a que hace referencia este término de seguridad informática.

Veamos algunos puntos de la seguridad informática a tener en cuenta desde un punto de vista de sistemas y desarrollos.

  • Conexiones cifradas

  • Conexiones seguras solo las conexiones internas.

  • Conexiones externas mediante VPN.

  • Conexiones externas punto a punto.

  • Limitar al máximo las conexiones externas.

  • Limitar el número de conexiones a ser posible.

  • Redes separadas por departamentos.

  • Limitación en el tipo de tráfico de entrada y salida dependiendo del departamento.

  • Seguridad en los accesos(control de accesos) a los servidores.

  • Código limpio y sin accesos o contraseñas.

  • Antivirus para los usuarios de Windows.

  • Cortafuegos por Firewall.

  • Cortafuegos por Software.

  • Software y lenguajes lo más posible actualizados.

  • Backup discos y Backup de datos

Teniendo todos estos puntos en cuenta, además de alguna cosilla más dependiendo del tipo de instalación o servicio que se quiera crear, tendríamos un sistema seguro al 100%.

¿Pero estamos seguros que nuestra seguridad informática es 100% segura?¿Depende solo de nosotros?

La segunda pregunta responde la primera, y aunque no existiera la segunda pregunta la respuesta sería la misma NO.

Porque la seguridad informática nunca será 100% fiable. Esto va a depender del tipo de red del que estamos hablando, a más usuarios más posibilidades de fallo, a más servicios más posibilidades de error. Y es que entre las nuevas actualizaciones, las apariciones de errores en código, los nuevos errores en software, la potencia de hardware que crece exponencialmente, las nuevas velocidades de nuestras redes… Es normal que tengamos que estar detrás de la seguridad informática para que al menos estemos al 99.999% seguros de que es fiable.

Pero todo esto es controlable o por lo menos monitorizable, entonces ¿donde esta el eslabón débil? No busques muy lejos, eres tú mismo, somo confiados por naturaleza y nos conectamos a las redes que al menos parecen legales y no provechosas, redes de cafeterías, redes de empresas, redes de aeropuertos o redes “oficiales”.

Esto es un error grave, nunca deberías conectarte a una red de alguien desconocido, y mucho menos conectarte a un red pública. ¿Por qué?

  • No sabes quién ha creado esa red.

  • No sabes quién más hay conectado a esa red.

     

Y es que por ejemplo, una buena norma de seguridad sería no dar la clave wifi a nadie que no sea de ese núcleo familiar. Aunque tampoco sería una norma 100% fiable, alguien podría llegar con un dispositivo hackeado, comprometiendo la red y todos sus dispositivos.

La única buena solución para nuestros problemas de seguridad informática es la formación y educación en ciertos aspectos tanto para administradores, programadores, empleados de cualquier departamento, los jefes de departamento y de forma individual son conceptos que tenemos que intregar en nuestro día a día.

Reflexiones acerca del Posicionamiento web 2021

Posicinamiento SEO, El SERP
Posicinamiento SEO, El SERP

Reflexiones acerca del Posicionamiento Web

Hace ya años que tenemos empresarios cada vez más preocupados por su posicionamiento web y la apariencia de sus empresas en los principales buscadores.

Al igual que yo que llevo cerca de diez años estudiando las distintas formas de posicionamiento orgánico para empresas y sus productos o servicios. Como administrador de sistemas y programador, además de 17 años de experiencia como electricista, siempre he tenido otro punto de vista sobre la formación que debería tener alguien para ofrecer mejoras en nuestras web, ya que mi visión sobre la red siempre ha sido un conjunto gracias a las tres aptitudes, con el objetivo siempre de mejorar el posicionamiento web en las búsquedas de internet he continuado mi formación tanto en programación, como administración y Posicionamiento Web.

Y la verdad, si no tienes un buen equipo detrás, se me hace raro, que alguien que sabe soló de posicionamiento orgánico pueda recomendar ninguna mejora que salga de mejorar las cabeceras de la web, estrategia SEO de los textos, títulos y URL’s.

No lo veo revisando el incremento de gastos para mejorar las capacidades de un servidor, el utilizar o no utilizar WordPress para tú web o tú proyecto, así como en el uso de la web o herramienta a utilizar y la formación de quién la va ha utilizar. Hay tantos detalles en un servidor, su sistema operativo y su uso, que no se pueden dejar atrás y en manos de terceros.

Podemos tener la mejor estrategia SEO aplicada, pero si nuestra web tardá 6 segundos en cargar todo el trabajo no valdrá de nada, sí en nuestra web se hace difícil programar o publicar una serie de post, se nos hará un mundo este proceso. De que nos sirve tener un web hecha exclusivamente a código para nosotros, si luego no podemos tener un backend ameno y universal para facilitar a los editores la distintas publicaciones, la sincronización con redes sociales, automatización de sitemaps y utilizar las distintas herramientas que ya existen.

Un buen estratega SEO además de contar con experiencia en la visión de datos Analytics, controlar Google Search Console, tener un amplio conocimiento en vocabulario, ser una persona dinámica y adaptable a los cambios rápidos; Debe tener aptitudes y conocimientos de administración y programación, sino como crear campañas solventes y adaptables, como utilizar y dar justificaciones de nuestros servicios y servidores.

Un buen estratega SEO debería poder llevar tú máquina a trabajar al 100% de sus posibilidades.

Un buen estratega SEO debería ser capaz de crear un red de páginas y controlarla.

Un buen estratega SEO debe dar indicaciones claras y ser capaz de justificarlas.

Un buen estratega SEO debe tener conocimientos sobre machine-learning para poder tener otros puntos de vista, y es que, debe ser un DataScients debido a la gran cantidad de datos que debe manejar.

Un buen estratega SEO debe saber que herramientas utilizar en cada momento, ¿Estás seguro que tú problema es la competencia?. Primero asegurate de mostrar lo que quierés en la red y como lo estás mostrando actualmente.

El posicionamiento web, más concretamente el posicionamiento orgánico no aporta siempre las mejores estadísticas, el que trae un tráfico de calidad. Le mejora en el SERP no son tres puntos y miles de palabras clave, la mejora en el posicionamiento SEO consta de un conjunto, de un histórico y un trabajo que se aprecia con el tiempo y la constancia.

Ánimo y escuchen al Friki que tienen al lado.

Resumen Postgresql

PostgreSQL Logo
PostgreSQL Logo

PostgreSQL

Postgresql creado en la Universidad de Berkley, es un sistema gestor de bases de datos relacional, que utiliza el puerto 5432 para su comunicación con los sistemas.

Los podemos descargar desde aquí, instalación que recomiendo pese a estar en los repositorios de Ubuntu.

Su usuario principal es postgres, del cuál nos pedirá una contraseña durante la instalación.

Tenemos varios programas para utilizar postgres:

  • En modo terminal psql
  • En modo gráfico pgadminIII
  • En modo web pgpadmin

Para trabajar en modo terminal deberemos acudir a la carpeta donde están los archivos binarios del sistema gestor de bases de datos en este caso:

  • /opt/PostgresSQL/9.3/bin

Una vez situados allí, tenemos acceso a todos los archivos ejecutables de Postgres, ahora solo nos falta cambiar de usuario, estos binarios únicamente los puede ejecutar el usuario “postgres”

Crear una base de datos

./createdb Nombre_base_datos

Entrar en la base de datos

./psql Nombre_base_datos

Crear tablas

CREATE TABLE nombre_tabla (

nombrecampo tipo restriccionescampo,

nombrecampo2 tipo restriccionescampo);

Borrar y modificar tablas

DROP TABLE nombre_tabla; (para crear)

ALTER TABLE nombre_tabla; (para modificar)

El prompt de postgres

Cuando el prompt se muestre con un igual (=) esto querrá decir que la sentencia que hemos introducido estará acabada, pero si nos muestra un guión (-) el prompt nos esta diciendo que la sentencia no esta acabada.

Creando restricciones

Clave primaria:

  • constraint persona_pk primary key (dni);

Clave foránea:

  • constraint dept2pers_fk foreign key (boss) REFERENCES persona (dni);

Como importar y exportar bases de datos.

Importar

En muchas bases de datos tendremos abrazadas mortales, por el momento sabemos que hay de varios tipos y que pueden ser muy habituales, para proceder de una manera correcta lo haremos de la siguiente manera, tendremos dos archivos por un lado las sentencias SQL que nos crean las tablas y las restricciones y por otro lado los datos.

  1. Primero abrimos el archivo que nos crea las tablas y restricciones con un editor de texto, de este separemos las creación de las tablas y los campos de las restricciones, algo que no será muy díficil ya que las restricciones siempre están al final del archivo, normalmente en formato SQL.
  2. Una vez hayamos separado esto último en dos archivos, utilizaremos únicamente el de la creación de tablas y campos y procederemos a la recuperación de la base de datos.
    1. ./psql base_datos < archivo_creador_tablas_y_campos.sql
  3. Ahora haremos los mismo con los datos, No con el archivo de restricciones resultante de la edición del paso 1!!.
    1. ./psql base_datos < archivo_con_datos.sql
  4. Cuando ya tengamos nuestra base de datos con las tablas y sus campos, y con todos los datos introducidos podemos pasar a la introducción de las restricciones.
    1. ./psql base_datos < archivo_con_restricciones.sql

Ya habremos recuperado nuestra base de datos con todos sus restricciones.

Exportar

De momento conoceremos la manera sencilla de exportación que no es más que realizar una copia de la base de datos entera, con tablas, campos, restricciones y datos.

./pg_dump base_datos > /home/usuario/fichero_backup.sql

Solo el esquema ./pg_dump -s base_datos > /home/usuario/fichero_backup_schema.sql

Solo los datos ./pg_dump -a base_datos > /home/usuario/fichero_backup_datos.sql

Backup all database
/usr/pgsql-10/bin/pg_dumpall -U postgres -h 127.0.0.1 -w > /tmp/postgresql_backup.sql
Restore all database
psql -f db.out postgres

Realizar consultas SQL

Todas las consultas SQL tienen el mismo formato:

SELECT – lista de campos (campo1,campo2,campo3)

AS – Alias para los campos

FROM – tablas a las que accedemos (también podemos utilizar alias para las tablas, tablaraul r, donde r sería el alias)

WHERE – Condiciones

Ejemplo consulta SQL

SELECT nom_regio AS regio, nom_pais AS pais

FROM public.region r, public.pais p

WHERE r.idregio = p.idpais;

SELECT nom_departament AS dpto, nom |’_’| cognoms AS cap

FROM departaments d, empleats e

WHERE d.idcap = e.idempleat;

Queremos conocer los datos de los empleados cuyo nombre  es Ferran

SELECT *

FROM empleats

WHERE nom LIKE ‘Ferran’; (LIKE) Solo con varchar, realizar búsquedas más finas

o

WHERE nom LIKE ‘f%’; % es un comodín para las búsquedas, nos dará los datos de todos los empleados que empieza su nombre por F

Quiero que me liste los atributos de los empleados cuyo nombre es formado por 4 letras

SELECT *

FROM empleats

WHERE nom LIKE ‘____’; (_ ) Comodín para el cáracter

Quiero saber todos los datos de las personas que cobren entre 1000€ y 2000€

SELECT *

FROM personas

WHERE sou Between 1000 AND 2000;

o

WHERE sou>=1000 AND sou<=2000;

Mongo DB / Administración

Mongo Db Logo
Mongo Db Logo

Importar de Json a MongoDB

sudo ./mongoimport –db actitvitat1 –collection people < ../data/db/persons.json

Crear sentencias Mongo

  1. Ens connectem al servidor mongo a la base de dades activitat1
    sudo ./mongo localhost/activitat1
  2. Mostrem tot el contingut de la col·lecció people
    db.people.find()
  3. Mostrem tot el contingut de la col·lecció people d’una manera més llegible.
    db.people.find().toArray()
  4. Mostrem les persones de 34 anys d’una manera llegible
    db.people.find({age:34}).toArray()
  5. Mostrem les persones de 34 anys i que siguin actius.
    db.people.find({age:34,isActive:true}).toArray()
  6. Mostrem el nom, l’edat i si són actius de les persones de 34 anys que siguin actius.
    db.people.find({age:34,isActive:true,{name:1,age:1}}).toArray()
  7. Mostrem el nom, l’edat i si són actius de les persones de 34 anys que siguin actius però desactivant el camp _id de la projecció.
    db.people.find({age:34,isActive:true},{name:1,age:1,_id:0}).toArray()
  8. Mostra una persona que compleixi els requeriments anteriors.
    db.people.find({age:34,isActive:true},{name:1,age:1,_id:0}).limit(1)
  9. Mostrem el nom i la edat de les persones que tenen més de 30 anys
    db.people.find({age:{$gte:30}}).toArray()
  10. Mostrem el nom i la edat de les persones que tenen 30 o més anys
    db.people.find({age:{$gte:30}},{name:1,age:1,_id:0}).toArray()
  11. Mostrem el nom i la edat de les persones menors de 30 anys
    db.people.find({age:{$lt:30}},{name:1,age:1,_id:0}).toArray()
  12. Mostrem el nom i la edat de les persones que no tenen 30 anys
    db.people.find({age:{$ne:30}},{name:1,age:1,_id:0}).toArray()
  13. Mostrem el nom i la edat de les persones que tenen 25, 30 o 35 anys
    db.people.find({age:{$in:[25,30,35]}},{name:1,age:1,_id:0}).toArray()
  14. Busquem els documents el camp gender sigui «female» i el camp age sigui més gran que 20.
    db.people.find({age:{$gte:30},gender:”female”},{name:1,age:1,_id:0}).toArray()
  15. Busquem els documents el camp gender sigui «female» o el camp age sigui més gran que 20
    db.people.find({$or:[{age:{$gte:30}},{gender:»female»}]},{name:1,age:1,_id:0}).toArray()
  16. Busquem els documents el camp gender sigui «female» i el camp age sigui més gran que 20 utilitzant l’operador $and.
    db.people.find({$and:[{age:{$gte:30}},{gender:»female»}]},{name:1,age:1,_id:0}).toArray()
  17. Busca les persones a people en que la seva edat és més gran que 30, o el gènere és «female» i la seva edat més gran que 50.
    db.people.find({$or:[{age:{$gte:30}},{$and:[{gender:»female»,age:50}]}]},{name:1,age:1,_id:0}).toArray()
  18. Busquem les persones edat NO sigui més gran que 30 i el camp isActive NO sigui true.
    db.peole.find({$and:[{age:{$lt:30}},{isActive:false}]})
  19. Busca l’element «laborum» a l’array tags, retornant les persones en el que en aquest array existeixi aquest element
    db.peole.find({$and:[{age:{$lt:30}},{isActive:false}]})
  20. Volem trobar totes les persones que continguin en tags els valors laborum i sunt.
    db.people.find({$and:[{tags:»laborum»},{tags:»sunt»}]}).toArray()
  21. Volem trobar totes les persones que continguin en tags alguns dels valors laborum, sunt, nisi
    db.people.find({tags:{$all:[«laborum»,»sunt»,»nisi»]}}).toArray()
  22. Volem trobar totes les persones que NO continguin a l’array tags alguns dels valors especificats: laborum, sunt i, nisi
  23. Retornar tots els documents on l’array tags té una mida de 3 elements
  1. Volem trobar totes les persones que continguin en tags alguns dels valors laborum, sunt, nisi
    db.people.find({tags:{$all:[«laborum»,»sunt»,»nisi»]}}).toArray()

Leer Sentencias Mongo

  1. db.people.find({«friends.2.name»:{$gte:»T»}}).count()
    Cuenta las per
  2. db.people.find({«friends.2.name»:{$gte:»T»}},{_id:0,name:1}).sort({name:1})
  3. db.people.find({«friends.2.name»:{$gte:»T»}},{_id:0,name:1}).sort({name: -1})
  4. db.people.find({«friends.2.name»:{$gte:»T»}},{_id:0,name:1,email:1}).sort({name:1,email:1})
  5. db.people.find({«friends.2.name»:{$gte:»T»}},{name:1}).limit(5)
  6. db.people.find({«friends.2.name»:{$gte:»T»}},{name:1}).skip(5)
  7. var myArray = db.people.find({«friends.2.name»:{$gte:»T»}},{name:1}).toArray()
  8. db.people.find({«friends.2.name»:{$gte:»T»}},{name:1}).skip(10).limit(5)
  9. db.people.find({«friends.2.name»:{$gte:»T»}}, {name:1}).sort({name:1}).limit(1)

Backup

Coger todos las bases de datos de mongo

  • mongo –eval db.getMongo().getDBNames().join(‘\n’) –quiet

Con Usuario

  • mongo –authenticationDatabase MONGO_DB_AUTH –username Mongo_User –password Mongo_Pass –eval db.getMongo().getDBNames().join(\n) –quiet

Ya tenemos en nuestra variable de bash todas las db que tenemos activadas en mongo, vamos a obtener las colecciones

  • mongo –eval db.getCollectionNames().join(‘\n’) –quiet

Con Usuario

  • mongo –authenticationDatabase MONGO_DB_AUTH –username Mongo_User –password Mongo_Pass –eval db.getCollectionNames().join(‘\n’) –quiet

Backup de la BD entera

  • mongodump –db NAME_DB –host localhost –out PATH_BACKUP

Con Usuario

  • mongodump –authenticationDatabase $MONGO_AUTH_DB –username $MONGO_USER –password $MONGO_PASS –db NAME –host localhost –out PATH_BACKUP

Backup Colecciones

  • mongodump –db NAME_DB –collection NAME_COLLECTION –host localhost –archives=NOMBRE_DB.NOMBRE_COLLECTION.HORA.archive

Con Usuario

mongodump –authenticationDatabase $MONGO_AUTH_DB –username $MONGO_USER –password $MONGO_PASS db NAME_DB –collection NAME_COLLECTION –host localhost –archives=NOMBRE_DB.NOMBRE_COLLECTION.HORA.archive

Restore Backup

Recuperar un backup de colecciones Entramos dentro del directorio donde tenemos todas las colecciones:


for x in `ls`;
do
mongorestore –archive=$x –db NAME_DB –port 27017;
done

Squid3 Proxy Server

Squid3 Proxy Transparent Server
Squid3 Proxy Transparent Server

Servidor Proxy. Squid3

Servidor proxy o intermediario

Es un programa o dispositivo que lleva a cabo tareas de acceso a Internet en el lugar de otro ordenador. Es un punto intermedio entre un ordenador conectado a Internet y el servidor al cuál esta accediendo.

Hay miles de servidores proxy repartidos por el mundo, muchos de ellos gratuitos. Es importante tener en cuenta que este tipo de servidor intermedio lo podemos utilizar para ocultar nuestra propia dirección IP, deberíamos cruzar varios servidores introduciendo en cada server nuevo la dirección obtenida por el anterior. Cabe decir, que tu camino seguido en la red quedará registrado igualmente, aunque tu auténtica dirección ip estará tras los servidores  proxy o pasarela.

Servidor-proxy.png

Ventajas

  1. Las pasarelas permiten únicamente aquellos servicios para los cuales hay un servidor intermedio habilitado.
  2. El protocolo tambíen puede ser filtrado, por ejemplo, filtrando el protocolo  FTP, seria posible prohibir el uso de la orden «put».
  3. Podemos filtrar direcciones IP.
  4. El acceso a las páginas web es mucho más rápido.
  5. Los usuarios no tienen acceso al encaminador, comunicación bajo control.
  6. Filtración de web y palabras.
  7. Guarda informe de las conexiones
  8. Más protección delante de ataques externos.

Desventajas

  1. Hace falta configurar todas las aplicaciones para que tengan acceso a internet.
  2. Si el servidor proxy falla, la red se quedará sin internet.
  3. Requiere mantenimiento.

Hay miles de servidores proxy repartidos por el mundo, muchos de ellos gratuitos. Es importante tener en cuenta que este tipo de servidor intermedio lo podemos utilizar para ocultar nuestra propia dirección IP, deberíamos cruzar varios servidores introduciendo en cada server nuevo la dirección obtenida por el anterior. Cabe decir, que tu camino seguido en la red quedará registrado igualmente, aunque tu auténtica dirección ip estará tras los servidores  proxy o pasarela.

Squid para Linux

A Continuación el comando para la instalación y la ubicación del archivo de configuración de Squid en Debian o Ubuntu.

  • apt-get install squid
  • /etc/squid/squid.conf

Algunas de las configuraciones que encontraremos dentro del archivo squid.conf son:

http_port. Sirve para indicar el puerto donde trabaja este servidor, así como la dirección ip que tiene asignada.

  • http_port 3128
  • http_port 192.168.10.50:8080

cache_mem. Indicaremos la capacidad de memoria de nuestro caché en el servidor proxy. Hay que tener en cuenta que ponemos un 16MB para 128 MB de RAM.

  • cache_mem 16MB

cache_dir. El tamaño que le queremos dar una nuestra memoria proxy que, sera la encargada de almacenar nuestras páginas favoritas entre otras cosas.

  • cache_dir ufs /var/spool/squid 1024  1  256. Siendo 1024 al capacidad otorgada.

cache_mgr. Opción en la configuración para enviar un correo electrónico en caso de fallida.

  • cache_mgr 12345@gmail.com

cache_replacement-policy. Podemos utilizar direrentes algoritmos para gestionar la memoria proxy.

  • LRU Least Recently Used
  • LFUDA Least Frequently Used with Dynamic Aging
  • GDSF GreedyDual size Frequency

Una muestra de un archivo de configuración:

Servidor-squid.png Como podéis ver, primero se crean la reglas (acl). Podemos crear reglas tanto como para horarios, palabras, direcciones web, subredes… A continuación os comento algunas de ellas.

Para prohibir palabras,direcciones web o subredes deberemos crear un archivo alternativo al de configuración de Squid para cada objetivo, es decir, uno para palabras prohibidas o admitidas, otro para las subredes prohibidas o admitidas y otro para las direcciones web exactamente igual.

Para los horarios basta con conocer el código internacional de los días… M-Monday, T-Tuesday, W-Wednesday, H-Thursday, F-Friday, A-Saturday y S-Sunday.

El cache de nuestro servidor proxy se encuentra en /var/spool/squid3

Si instalamos calamaris, podemos generar informes listos para impresión de los diferentes accesos a nuestro proxy,

  • apt-get install calamaris
  • sudo cat /var/log/squid3/access.log | calamaris

Varnish – Apache2 – WordPress

wordpress logo
Varnish - Apache y WordPress
wordpress logo

Que es Varnish

Varnish es un acelerador HTTP, el cual almacena en caché los recursos de un servidor web y puede
crear la misma página una y otra vez cuando el usuario lo solicite. Se ejecuta frente a un servidor Web y
sirve las páginas mucho más rápido.

Funcionalidades

  • Equilibrio de Carga
  • Reescritura de URL
  • Comprobación de Backends
  • Manejo elegante de backend muertos
  • Soporte parcial para ESI(Edge Side Includes)

Arquitectura

  • Caché monolítica mapeada a memoria virtual
  • Archivos configuración compilados en C
  • Trata todo el ciclo de vida de una petición
  • Cambios de configuración en caliente
  • Logs escritos en memoria compartida

Herramientas

varnishtop ->Lista ocurrencias de los log mÃąs comunes
varnishstat ->Estadísticas en tiempo de real
varnishhist ->Hits y misses en tiempo real
varnishlog / varnishncsa ->Generan logs tradicionales
varnishreplay ->Parsea logs y reduce el trÃąfico
como validar la configuración -> varnishd -C -f /etc/varnish/default.vcl


Compilación de Varnish 4.1 en CentOs7

Para poder compilar sin problemas debemos tener instalados los siguientes paquetes:

pygpgme
yum-utils
epel-release-n
Para instalar epel-release-6 (Servidor de pruebas 6.9)


Vamos al directorio de repositorios y creamos el nuestro para Varnish

/etc/yum.repos.d/

Creamos el archivo varnishcache_varnish41.repo con el siguiente contenido:

[varnishcache_varnish41]

name=varnishcache_varnish41

baseurl=https://packagecloud.io/varnishcache/varnish41/el/6/$basearch

repo_gpgcheck=1

gpgcheck=0

enabled=1

gpgkey=https://packagecloud.io/varnishcache/varnish41/gpgkey

sslverify=1

sslcacert=/etc/pki/tls/certs/ca-bundle.crt

metadata_expire=300

[varnishcache_varnish41-source]

name=varnishcache_varnish41-source

baseurl=https://packagecloud.io/varnishcache/varnish41/el/6/SRPMS

repo_gpgcheck=1

gpgcheck=0

enabled=1

gpgkey=https://packagecloud.io/varnishcache/varnish41/gpgkey

sslverify=1

sslcacert=/etc/pki/tls/certs/ca-bundle.crt

metadata_expire=300


Procedemos a la instalación:

sudo yum -q makecache -y –disablerepo=’*’ –enablerepo=’varnishcache_varnish41′


Configuración Varnish

Parámetros de Arranque

Parámetros de arranque de Varnish, archivos de configuración:
/etc/sysconfig/varnish ->RedHat, CentOS, etc
/etc/default/varnish ->Debian, Ubuntu
# cat /etc/sysconfig/varnish
# Maximum number of open files (for ulimit -n)
NFILES=131072
# Locked shared memory (for ulimit -l)
# Default log size is 82MB + header
MEMLOCK=82000
# Maximum number of threads (for ulimit -u)
NPROCS=»unlimited»
# Maximum size of corefile (for ulimit -c). Default in Fedora is 0
# DAEMON_COREFILE_LIMIT=»unlimited»
# Init script support to reload/switch vcl without restart.
# To make this work, you need to set the following variables
# explicit: VARNISH_VCL_CONF, VARNISH_ADMIN_LISTEN_ADDRESS,
# VARNISH_ADMIN_LISTEN_PORT, VARNISH_SECRET_FILE.
RELOAD_VCL=1
# Set WARMUP_TIME to force a delay in reload-vcl between vcl.load and vcl.use
# This is useful when backend probe definitions need some time before declaring
# configured backends healthy, to avoid routing traffic to a non-healthy backend.
#WARMUP_TIME=0
# Main configuration file.
VARNISH_VCL_CONF=/etc/varnish/default.vc
# Default address and port to bind to
# Blank address means all IPv4 and IPv6 interfaces, otherwise specify
# a host name, an IPv4 dotted quad, or an IPv6 address in brackets.
VARNISH_LISTEN_PORT=80
# Telnet admin interface listen address and port
VARNISH_ADMIN_LISTEN_ADDRESS=127.0.0.1
VARNISH_ADMIN_LISTEN_PORT=6082
# Shared secret file for admin interface
VARNISH_SECRET_FILE=/etc/varnish/secret
# The minimum number of worker threads to start
VARNISH_MIN_THREADS=50
# The Maximum number of worker threads to start
VARNISH_MAX_THREADS=1000
# Cache file size: in bytes, optionally using k / M / G / T suffix.
VARNISH_STORAGE_SIZE=256M
# Backend storage specification
VARNISH_STORAGE=»malloc,${VARNISH_STORAGE_SIZE}»
# Default TTL used when the backend does not specify one
VARNISH_TTL=120
# DAEMON_OPTS is used by the init script.
DAEMON_OPTS=»-a ${VARNISH_LISTEN_ADDRESS}:${VARNISH_LISTEN_PORT} \
-f ${VARNISH_VCL_CONF} \
-T ${VARNISH_ADMIN_LISTEN_ADDRESS}:${VARNISH_ADMIN_LISTEN_PORT} \
-p thread_pool_min=${VARNISH_MIN_THREADS} \
-p thread_pool_max=${VARNISH_MAX_THREADS} \
-S ${VARNISH_SECRET_FILE} \
-s ${VARNISH_STORAGE}»
Las opciones más importantes son VARNISH_PORT Y VARNISH_VLC_CONF, sin estas dos parámetros no funcionará.
 

Funciones Varnish – Rutinas

Cuando una petición HTTP llega a Varnish, éste la procesa llamando a las diferentes rutinas en un orden concreto, y se ejecuta el código que hay dentro de dichas subrutinas. Ese código puede ser el código por defecto de Varnish o bien código personalizado por nosotros.

De estas rutinas las que más vamos a usar son: vcl_recv() y vcl_fetch(), aunque vamos a ver todas las opciones disponibles:*

  • vcl_recv() >Cuando se recibe una petición HTTP Varnish lanza esta subrutina. Nos permite decidir si la aceptamos o no, cómo hacerlo y que backend usar.
  • vcl_fecth() >Se ejecuta después de haber obtenido del backend HTTP los datos solicitados, después de haberse acepta la petición de vcl_recv().

En todas las funciones podemos realizar diferentes acciones, para ello tenemos la función return() con las diferentes acciones dentro de ella:

  • pass ->Si para la petición en curso devolvemos pass, la peticiÃşn se envia al servidor Backend sin buscarse en la caché y la respuesta del backend http se devuelve al usuario sin cachearse.
  • pipe ->Esta acciÃşn çortocircuita. el cliente HTTP y el Backend HTTP de forma que Varnish se limita a transferir datos de uno a otro. Es similar a pass (no se cachea) y ademÃąs Varnish no se dedica a inspeccionar el trÃąfico HTTP ni rellenar los objetos req/beresp/obj por lo que a veces se utiliza para evitar que objetos muy grandes (vÃŋdeos, etc) sean «procesados»por varnish.
  • lookup ->Fuerza a Varnish a que devuelva el objeto desde la caché incluso si la petición en sí mísma está solicitando contenido no cacheado.
  • deliver ->Le indica a Varnish que queremos devolver el objeto cacheado si es posible.
  • hit_for_pass ->Similar a pass (pero accesible desde vcl_fetch) salvo porque crea un objeto de tipo hitforpass y lo que se hace en este caso es cachear la decisión de no cachear.
  • restart ->Una forma de volver a ejecutar la lógica desde el principio.
  • vcl_hash() >Permite alterar el hash que se utiliza para gestionar el objeto en la cachÃľ. Normalmente es la URL pero podemos alterar dicho hash a nuestra voluntad. Un ejemplo sería cachear la página del perfil (/profile/) de cada usuario, aÃśadiendo concatenando la cookie de usuario a la URL, lo que generaría un objeto distinto en cada para cada usuario.
  • vcl_pipe() >Modo Pipe
  • vcl_pass() >Podemos forzar a que se reinicie la transacción, lo cual incrementa un contador interno de restart»que podemos detectar en otras funciones.
  • vcl_hit() >Llamada cuando lookup en la caché encuentra un objeto válido.
  • vcl_miss() >Es llamada cuando lookup no encuentra un objeto válido.
  • vcl_error() >LLamada cuando se encuentra un error por cualquier motivo.
  • vcl_deliver() >Es llamada antes de que un objeto cacheado sea entregado al cliente HTTP.

Configuración Caché

Tenemos el fichero /etc/varnish/default.vlc

Archivo de ejemplo:
# This is a basic VCL configuration file for varnish. See the vcl(7)
# man page for details on VCL syntax and semantics.
#
# Default backend definition. Set this to point to your content
# server.
#
backend default {
.host = «127.0.0.1»;
.port = «8080»;
sub vcl_recv {
# Happens before we check if we have this in cache already.
# Typically you clean up the request here, removing cookies you don’t need,
# rewriting the request, etc.
#Capamos las cookies de wordpress para wp-login y wp-admin
if (!(req.url ~ «wp-(login|admin)»)) {
unset req.http.cookie;
}
#Capamos para el de cookies que podrían afectar al administrador
set req.http.cookie = regsuball(req.http.cookie, «wp-settings-\d+=[^;]+(; )?», «»);
set req.http.cookie = regsuball(req.http.cookie, «wp-settings-time-\d+=[^;]+(; )?», «»);
set req.http.cookie = regsuball(req.http.cookie, «wordpress_test_cookie=[^;]+(; )?», «»);
if (req.http.cookie == «») {
unset req.http.cookie;
}
#No se cachea todo lo que acabe con wp-admin o wp-login
if (req.url ~ «wp-admin|wp-login») {
return (pass);
}
}
sub vcl_backend_response {
# Happens after we have read the response headers from the backend.
# Here you clean the response headers, removing silly Set-Cookie headers
# and other mistakes your backend does.
}
sub vcl_deliver {
# Happens when we have all the pieces we need, and are about to send the
# response to the client.
# You can do accounting or modifying the final object here.
}
 
El lenguaje de configuración de Varnish llamado VCL(Varnish Configuration Language). En esta configuración debemos definir una serie de subrutinas y código dentro de las mismas. Varnish llamará a cada una de esta subrutinas en algún punto de la petición.
Este lenguaje soporta estructuras «tipo if, include, comentarios de como //, /* */ y , salida de funciones con return(), asignaciones con =, comparaciones con ==, negaciÃşn con !, and y or lógico con y ||, matche o contra expresiones regulares con y establecer/eliminar atributos con set y unset. También tenemos funciones como regsub y regsuball (sustituciÃşn por expresiones regulares de una o todas las ocurrencias).
 

Varnish y WordPress

Varnish y el contenido dinámico de WordPress (prácticamente todo) no se llevan muy bien, para ello debemos configurar varnish para que ciertos contenidos los muestre estáticamente.
Ejemplo default.vcl para WordPress

vcl 4.0;

import std;

# Default backend definition. Set this to point to your content server.

backend default {

.host = «127.0.0.1»;

.port = «8080»;

}

#Backend net-lz.com

backend netlz {

.host = «127.0.0.1»;

.port = «8080»;

}

#Backend gamesranking.info

backend gamesranking {

.host = «127.0.0.1»;

.port = «8080»;

}

#Backend trailersdecine.com

backend trailersdecine {

.host = «127.0.0.1»;

.port = «8080»;

}

sub vcl_recv {

#Control para ver que backend utilizar

if (req.http.host == «www.net-lz.com» || req.http.host == «net-lz.com»){

set req.backend_hint = netlz;

} elseif (req.http.host == «www.gamesranking.net» || req.http.host == «gamesranking.net»){

set req.backend_hint = gamesranking;

} elseif (req.http.host == «www.trailersdecine.com» || req.http.host == «trailersdecine.com»){

set req.backend_hint = trailersdecine;

}else {

set req.backend_hint = default;

}

#Si la petición es para 443 nos aseguramos que lo marqué en las cabeceras HTML
if (std.port(server.ip) == 443){
set req.http.X-Proto = «https»;

}

#Tipos de codificaciones aceptadas

if (req.http.Accept-Encoding) {

if (req.url ~ «\.(gif|jpg|jpeg|swf|flv|mp3|mp4|pdf|ico|png|gz|tgz|bz2)(\?.*|)$») {
# remove req.http.Accept-Encoding;
} elsif (req.http.Accept-Encoding ~ «gzip») {

set req.http.Accept-Encoding = «gzip»;

} elsif (req.http.Accept-Encoding ~ "deflate") {

set req.http.Accept-Encoding = «deflate»;

} else {

#remove req.http.Accept-Encoding;

}

}

#Consultas archivos multimedia

if (req.url ~ «wp-content/themes/» && req.url ~ «\.(gif|jpg|jpeg|swf|css|js|flv|mp3|mp4|pdf|ico|png)(\?.*|)$») {

unset req.http.cookie;

set req.url = regsub(req.url, "\?.*$", "");

}

#Consultas a otro tipos de archivos

if (req.url ~ «\?(utm_(campaign|medium|source|term)|adParams|client|cx|eid|fbid|feed|ref(id|src)?|v(er|iew))=») {

set req.url = regsub(req.url, "\?.*$", "");

}

# no cacheamos las cookies de administrador

# soluciona la redirección que se generaba al querer entrar como administrador

if (req.http.cookie) {

if (req.http.cookie ~ «(wordpress_|wp-settings-)») {

return(pass);

} else {

unset req.http.cookie;

}

}

#Desactivamos la cache para esta url

if (!(req.url ~ «wp-(login|admin)»)) {

unset req.http.cookie;

}

#No cacheamos cookies específicas de wordpress

set req.http.cookie = regsuball(req.http.cookie, «wp-settings-\d+=[^;]+(; )?», «»);

set req.http.cookie = regsuball(req.http.cookie, «wp-settings-time-\d+=[^;]+(; )?», «»);

set req.http.cookie = regsuball(req.http.cookie, «wordpress_test_cookie=[^;]+(; )?», «»);

#No cacheamos cookies en general

if (req.http.cookie == «») {

unset req.http.cookie;

}

#Pasamos sin cacheo las url con wp-admin y wp-login

if (req.url ~ «wp-admin|wp-login») {

return (pass);

}

}

#fin vcl_recv


sub vcl_backend_response {

set beresp.ttl = 10s;

set beresp.grace = 1h;

}

#Marcamos que debemos guardar cómo estadísticas

sub vcl_deliver {

if (obj.hits > 0) {

set resp.http.X-Cache = «HIT»;

} else {

set resp.http.X-Cache = «MISS»;

}

return (deliver);

}

Podríamos añadir una configuración para permitir la opción purge desde diferentes sitios, este no se ha hecho debido a que tenemos instalado un plugin en la red multisite de worpdress que nos ofrece esta funcionalidad y la configuración Varnish ha sido diseñada con esta objetivo. Ver: https://varnish-cache.org/trac/wiki/VCLExamples


Configuración Varnish especiales

REMOTE ADDRESS PHP

Para que PHP pueda capturar las Ip de los usuarios que se conectan debemos añadir algunos cambios al archivo default.vcl de varnish.


Añadimos la siguiente configuración dentro del la subrutina vcl_recv:


#Control Varnish para que PHP puede devolver las IP de los usuarios que se conectan

if (req.restarts == 0) {

if (req.http.x-forwarded-for) {


set req.http.X-Forwarded-For =

req.http.X-Forwarded-For + «, » + client.ip;


} else {

set req.http.X-Forwarded-For = client.ip;

}

}


Ahora nos faltará 2 procesos, añadir unas líneas al Vhost de correspondiente y crear un fichero php que se encargará de asegurarnos que cojamos la ip buena.


Vhost de ejemplo:

<VirtualHost *:8080>

DocumentRoot «/web/wordpress/static/trailersdecine»

ServerName trailersdecine.com

ServerAlias www.trailersdecine.com

<Directory /web/wordpress/static/trailersdecine>

#Linea para Varnish

php_value auto_prepend_file «/www/conf/sites/varnish_client_ip.php»

AllowOverride All

Order deny,allow

Allow from all

</Directory>


CustomLog logs/common.trailersdecine combined

ErrorLog logs/error.trailersdecine

#Linea y log para varnish

LogFormat «%{X-Forwarded-For}i %l %u %t \»%r\» %>s %b \»%{Referer}i\» \»%{User-Agent}i\»» varnish


# Other directives here

</VirtualHost>


Como podéis observar dentro de Directory podemos ver como se hace una llamada al archivo varnish_client_ip.php, vamos a crearlo con el siguiente cotenido:


<?phpif( isset( $_SERVER[ ‘HTTP_X_FORWARDED_FOR’ ] ) ) {

$_SERVER[ 'REMOTE_ADDR' ] = $_SERVER[ 'HTTP_X_FORWARDED_FOR' ];

}

?>


Con tal de no parar el servicio vamos a recargar ambos

service varnish reload

/www/bin/apachectl stop

/www/bin/apachectl start


Ya tenemos nuestro servicio ce cacheo listo


MOD HEADERS

Con tal de controlar las cabeceras que viene de http y https y permitir el trasposo de archivos multimedia entre estos dos protocolos debemos añadir configuración tanto a Varnish como en Apache.


Varnish mod_headers.

sub vcl_recv {
# Save Origin in a custom header
set req.http.X-Saved-Origin = req.http.Origin;
# Remove Origin from the request so that backend
# doesn’t add CORS headers.
unset req.http.Origin;
}
sub vcl_deliver {
if (req.http.X-Saved-Origin == «https://www.trailersdecine.com«
|| req.http.X-Saved-Origin == «http://www.trailersdecine.com«
|| req.http.X-Saved-Origin == «https://trailersdecine.com«
|| req.http.X-Saved-Origin == «http://trailersdecine.com«) {
set resp.http.Access-Control-Allow-Origin =
req.http.X-Saved-Origin;
}
if (resp.http.Vary) {
set resp.http.Vary = resp.http.Vary + «,Origin»;
} else {
set resp.http.Vary = «Origin»;
}
}
Apache mod_headers.
Para compilar el módulo si este no esta instalado:
/www/bin/apxs -i -c ./modules/metadata/mod_headers.c
Activación del módulo en Apache
En httpd.conf añadir al final
LoadModule headers_module /www/modules/mod_headers.so
En los Vhost de los dominios a controlar las cabeceras añadimos las línea:
Header set Access-Control-Allow-Origin «*»
Reiniciamos apache y Varnish y ya esta listo
 
 
 
 

Configuración Apache para Varnish

Como Varnish está a la escucha en el puerto 80, debemos indicarle a Apache que escuche en otro puerto, en este caso el 8080.

#Puertos de escucha

Listen *:8080

Listen *:443

#Módulos necesarios

LoadModule proxy_modulemodules/mod_proxy.so

LoadModule proxy_balancer_modulemodules/mod_proxy_balancer.so

LoadModule proxy_http_modulemodules/mod_proxy_http.so

LoadModulos mod_ssl

#NameVirtualHost

Este paso no es estrictamente necesario

NameVirtualHost *:8080NameVirtualHost 217.13.124.73:443


Virtualhost para sitios sin SSL

<VirtualHost *:8080> DocumentRoot «/web/wordpress/static/trailersdecine» ServerName trailersdecine.com ServerAlias www.trailersdecine.com <Directory /web/wordpress/static/trailersdecine> AllowOverride All Order deny,allow Allow from all </Directory> CustomLog logs/common.trailersdecine combined ErrorLog logs/error.trailersdecine # Other directives here</VirtualHost>

Es una configuración típica excepto con los puertos de escucha y con el puerto de escucha a la hora de configurar el Vhost: 8080.


Varnish y HTTPS

Archivo:Image1.png.png


Varnish no soporta HTTPS, no podemos configurar Varnish para que escuche el puerto 443 simplemente.


Para solucionar este problema debemos configurar el virtualhost de la siguiente manera:

Virtualhost 443
<VirtualHost 217.13.124.73:443>
ServerName trailersdecine.com
ServerAlias www.trailersdecine.com
ErrorLog logs/error_https.trailersdecine.com.log
CustomLog logs/access_https.trailersdecine.com.log combined
SSLEngine on
SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP:+eNULL
SSLCertificateFile «/etc/letsencrypt/live/trailersdecine.com/fullchain.pem»
SSLCertificateKeyFile «/etc/letsencrypt/live/trailersdecine.com/privkey.pem»
ProxyPreserveHost On
ProxypassReverse/ http://127.0.0.1:8080/
</VirtualHost>
Podemos apreciar varias cosas en este fichero:
No tiene la sentencia DocumentRoot
Creamos la contestación a partir de la dirección interna y el puerto del escucha de Apache2
Una vez creado el VirtualHost para el puerto 443, reiniciamos los servicios y ya tenemos Varnish – Apache – HTTPS funcionando.
En la configuración de apache deberemos añadir:
NameVirtualHost 217.13.124.73:443

Enlaces de referencia

https://bash-prompt.net/guides/apache-varnish/

Let’s encrypt

Comandos

Let’s encrypt

En RomSolutions la seguridad informática es muy importante, tanto o más que el posicionamiento SEO. Para tener un buen posicionamiento SEO debemos tener nuestra web bajo el protocolo HTTPS, sin este protocolo google no nos posicionará en sus listas.

Para obtener un certificado SSL tenemos varias opciones:

  • Como para la forma de obtenerlo,
  • El tipo de certificado que queremos obtener
  • Los dominios que abarcará este certificado.

Tenemos tres modos de ejecucción por defecto:

  • por defecto. letsencrypt-auto …. Este modo obtiene el certificado y lo instalo en el vhost correspondiente.
  • certonly. letsencrypt-auto certonly. Este modo solo obtiene el certificado
  • renew. Este método solo renueva el certificado

Certificado para uno o más dominios

letsencrypt-auto certonly -d dominio1.com -d pepe.dominio1.com -d dominio2.como

Certificado según la vía

letsencrypt-auto certonly –preferred-challenges dns -d dominio1.com
letsencrypt-auto certonly –preferred-challenges http -d dominio1.com
letsencrypt-auto certonly –preferred-challenges tls-sni -d dominio1.com (https)

Certificado via fichero de texto

letsencrypt-auto certonly –manual -d dominio1.com

Certificado indicando webroot

letsencrypt-auto certonly –webroot -w /tmp -d www.pepe.com -d pepe.com

WildCard

letsencrypt-auto certonly –server https://acme-v02.api.letsencrypt.org/directory –manual -d «*.dominio.com»

Nota: Para obtener el wildcard necesitaremos acceso al servidor de nombres DNS.

Renovación simple

letsencrypt-auto renew

Renovación apagando servicios

letsencrypt-auto renew –renew-hook=»/etc/rc.d/init.d/nginx restart»

Revocar un certificado

letsencrypt-auto revoke –cert-path /etc/letsencrypt/archive/${YOUR_DOMAIN}/cert1.pem

Comprobar certificado sin letsencrypt

openssl x509 -in <certificat> -noout -dates

Averiguar Dominios de un certificado

openssl x509 fichero -nouout -text

Let’s encrypt es una de las mejores opciones a la hora de obtener un certificado.

Linux – Bash

Bash Script

Un Shell Script no es más que un fichero con sentencias para el intérprete que se vaya a utilizar. Entre los intérpretes más utilizados se encuentran: Bash,Perl, Python y PHP para los entornos web.

Argumentos posicionales

En un script se pueden especificar argumentos en una línea de comando, es decir un nombre_de_script+un directorio o más un número o una letra. El script en bash accede a estos parámetros mediante las variables $0, $1, etc.:

  • $0 Nombre del script
  • $1 Argumento uno
  • $2 Argumento dos
  • $3 Argumento tres, así hasta el nueve.
  • $# Número de argumentos total
  • $* Cadena con todos los argumentos
  • shift Desplaza hacia la izquierda los arguementos, el 10 pasa a ser 9 y así posteriormente.
  • $? Código de retorno

El código de retorno

Cada programa que se ejecuta en el shell cuando termina guarda su código de retorno en la variable $?. Este código es un valor numérico que determina si el programa ha terminado de forma correcta. El código de retorno de valor 0 para la correcta ejecucción, cualquier otra valor para la incorrecta ejecucción.ç

  • $? Código de retorno

Algunos scripts con los principales operadores de bash. comprobar ficheros y directorios, condicionales, bucles, while, until, funciones, etc.:

Redirecciones de entrada y salida

Redirección de salida estándar a un archivo

*hace que el descriptor de archivo 6 sea una copia de stdout (descriptor archivo 1)
exec 6>&1
*abre el archivo "test.data" para escritura
exec 1>test.data
*genera algún contenido
echo "data:data:data"
*recupera stdout original, al hacer que sea una copia del descriptor de archivo 6
exec 1>&6
*Cierra el descriptor de archivo 6
exec 6>&-

Abre y cierra archivos

# abre el archivo test.data para lectura
exec 6<test.data
# lee hasta el final del archivo
while read -u 6 dta
do
  echo "$dta" 
done
# cierra el archivo test.data
exec 6<&-

Salida de órdenes externas

VAR=$(find . -name "*h")

Condicionales con números

  • -lt menor que <
  • -gt mayor que >
  • -le menor o igual que <=
  • -gr mayor o igual que >=
  • -eq igual ==
  • -ne no igual !=

Condionales con texto

  • = cadenas de texto exactemente iguales

!= cadenas de texto no iguales

  • <
  • >
  • -n la cadena no está vacía
  • -z la cadena está vacía

Condicionales con archivos

  • -e existe
  • -f archivo normal, no es un directorio
  • -s no tiene tamaño 0
  • -d es un directorio
  • -r tiene permiso de lectura para el usuario que lanza el script
  • -w permiso de escritura para el usua…
  • -x permiso de ejecución

Manipulación de texto

${cadena:posicion:longitud}
Por ejemplo en la cadena string=abcABC123ABCabc:
echo ${string:0} : abcABC123ABCabc
echo ${string:0:1} : a (primer caracter)
echo ${string:7} : 23ABCabc
echo ${string:7:3} : 23A (3 caracteres desde posición 7)
echo ${string:7:-3} : 23ABCabc (desde posición 7 hasta el final)
echo ${string: -4} : Cabc (atención al espacio antes del menos)
echo ${string: -4:2} : Ca (atención al espacio antes del menos)

Linux – Comando Sed

Trucos de consola usando sed

Finales de linea tipo DOS (CR/LF) a formato Unix.

sed ‘s/.$//’ # asume que todas las lineas terminan con CR/LF sed ‘s/\x0D$//’ # funciona con ssed, gsed 3.02.80 o superior

Borrarado espacios en blanco al principio y el final de cada linea
sed 's/^[ \t]*//;s/[ \t]*$//'
Alineando el texto a una anchura de 79 columnas
sed -e :a -e 's/^.\{1,78\}$/ &/;ta'  # set at 78 plus 1 space
Substituciones «foo» por «bar» en cada linea
  • sustituir solo la primera ocurrencia en la linea
    • sed ‘s/foo/bar/’
  • sustituir solo la cuarta ocurrencia en la linea
    • sed ‘s/foo/bar/4’
  • sustituir todas las veces que se encuentre
    • sed ‘s/foo/bar/g’
  • sustituir solo la anteultima ocurrencia
    • sed ‘s/\(.*\)foo\(.*foo\)/\1bar\2/’
  • sustituir solo la ultima ocurrencia
    • sed ‘s/\(.*\)foo/\1bar/’
  • sustituir "foo" por "bar" SOLO en las lineas que contengan "baz"
    • sed ‘/baz/s/foo/bar/g’
  • sustituir "foo" por "bar" EXCEPTO en las lineas que contengan "baz"
    • sed '/baz/!s/foo/bar/g'
Mostrar la linea numero 52
sed -n '52p'                 # metodo 1
sed '52!d'                   # metodo 2

sed '52q;d' # metodo 3, eficiente para ficheros grander

Quitar la mayoria de los tags HTML (reconoce tags multilinea)
sed -e :a -e 's/<[^>]*>//g;/</N;//ba'

Emulación algunos comandos

Contar lineas (emula «wc -l»)
sed -n '$='
Ordenar lineas al reves (emula «tac»)
sed '1!G;h;$!d'               # metodo 1
sed -n '1!G;h;$p'             # metodo 2
Invierta cada caracter de la linea (emula «rev»)
sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'
Une pares de lineas lado a lado (emula «paste»)
sed '$!N;s/\n/ /'
Muestra las 10 primeras lineas (emula «head»)
sed 10q
Muestra la 10 ultimas filas (emula «tail»)
sed -e :a -e '$q;N;11,$D;ba'
Muestra solo las lineas que se ajustan a la expresion regular (emula «grep»)
sed -n '/regexp/p'           # metodo 1
sed '/regexp/!d'             # metodo 2
Borra lineas duplicadas consecutivas (emula «uniq»)
sed '$!N; /^\(.*\)\n\1$/!P; D'

Referencias:

http://sed.sourceforge.net/sed1line.txt
http://sed.sourceforge.net/sedfaq.html
https://www.gnu.org/software/sed/manual/sed.html  

Comandos Docker

Docker

 
  1. Obtener información
  • docker info
  • docker network info
  • docker volume info
  1. Ver número de procesos levantados (contenedores levantados). Muy útil para encontrar de manera rápida el identificador del contenedor
  • docker ps
  1. Entra en un terminal del contenedor
  • docker exec it Id_container sh
  1. Entra en el log del contendor
  • docker attach Id_container
  1. Ver archivos de configuración
  • docker inspect Id_container
  1. Para borrar
  • docker system prune -a
  • docker image prune
  • docker container prune
  • docker volume prune
  • docker network prune
  1. Para listar
  • docker system ls
  • docker image ls
  • docker volume ls
  • docker network ls
  • docker container ls
  1. Descargar y levantar una imagen
  • docker run -d –name graphite –restart=always -p 8080:80 -p 2003-2004:2003-2004 -p 2023-2024:2023-2024 -p 8125:8125/udp -p 8126:8126 graphiteapp/graphite-statsd
  1. Parada y arrancada de un contenedor
  • docker stop name or id // docker start name or id
  1. Levantar una imagen descargada
  • docker build -t hopsoft/docker-graphite-statsd ./docker-graphite-statsd/
  1. Levantar imagen con compose
  • Debe lanzarse en el directorio donde se encuentre el archivo docker-compose.yml
    • docker-compose up
  1. Logs de los containers
  • docker logs name_container