Ahora dockerfile/ghost ha sido sustituido por ghost. Tenlo en cuenta cuando sigas el tutorial

Esta es la primera de dos partes de cómo he montado mi propio blog (Aquí puedes encontar la segunda parte). Este post explica la instalación de un entorno dev para mi blog basado en Ghost. Para ello he usado:

  • Ghost. Estuve bastante tentado a usar Wordpress, pero al final me decanté por Ghost porque me siento más cómodo cuando puedo leer el código del motor con el que estoy trabajando (en este caso, Node). Tranquiliza saber que sería muy fácil cambiar su comportamiento si fuera necesario.

  • Vagrant. Aunque es posible no utilizar Vagrant, esto implicaría instalar mi blog en mi Mac OS y desplegarlo en mi servidor Ubuntu. Vagrant me permite tener consistencia en mis entornos de desarrollo y de producción, porque son virtualmente idénticos. Así que con Vagrant monto mi entorno de dev en mi propia máquina sin guarrear mi S.O.

  • Docker. Esta plataforma simplifica el proceso de montar un proxy inverso o un motor de blogging evitando lidiar con las dependiencias asociadas.

El tema que he elegido es Ghostium, un tema que trata de ser lo más similar posible a Medium. Elegante y simple. Tiene la ventaja, además, de estar preparado y optimizado para ser un blog técnico. Otras buenas opciones que consideré fueron uno-zen y Velox

Montar entorno de dev

Lo primero que vamos a hacer es montar el entorno de desarrollo para dejarlo listo para pasarlo a producción.

Antes de continuar con el tuto asegúrate de tener correctamente instalado en tu máquina Vagrant. Podrás encontrar como hacerlo en su página.

Lo primero que deberemos hacer es crear un fichero Vagrantfile

    $ mkdir -p blog/src/content/{data,images,themes}
    $ wget https://raw.githubusercontent.com/TryGhost/Ghost/master/config.example.js -O blog/src/config.js

Edita el fichero blog/src/config.js con algo más o menos así:


// # Ghost Configuration
// Setup your Ghost install for various environments
// Documentation can be found at http://support.ghost.org/config/

var path = require('path'),
    config;

config = {
    // ### Production
    // When running Ghost in the wild, use the production environment
    // Configure your URL and mail settings here
    production: {
        url: 'http://myblog.com', // Tu URL de producción
        mail: {},
        database: {
            client: 'sqlite3',
            connection: {
                filename: path.join(__dirname, '/content/data/ghost.db')
            },
            debug: false
        },

        server: {
            // Host to be passed to node's `net.Server#listen()`
            host: '0.0.0.0',
            // Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
            port: '2368'
        }
    },

    // ### Development **(default)**
    development: {
        // The url to use when providing links to the site, E.g. in RSS and email.
        // Change this to your Ghost blogs published URL.
        url: 'http://myblog.dev',

        mail: {
            transport: 'SMTP',
            options: {
                service: 'Gmail',
                auth: {
                    user: '[tu user de gmail]',
                    pass: '[tu pass de GMail]'
                }
            }
        },

        database: {
            client: 'sqlite3',
            connection: {
                filename: path.join(__dirname, '/content/data/ghost-dev.db')
            },
            debug: false
        },
        server: {
            // Host to be passed to node's `net.Server#listen()`
            host: '0.0.0.0',
            // Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
            port: '2368'
        },
        paths: {
            contentPath: path.join(__dirname, '/content/')
        }
    },

    // **Developers only need to edit below here**

    // ### Testing
    // Used when developing Ghost to run tests and check the health of Ghost
    // Uses a different port number
    testing: {
        url: 'http://127.0.0.1:2369',
        database: {
            client: 'sqlite3',
            connection: {
                filename: path.join(__dirname, '/content/data/ghost-test.db')
            }
        },
        server: {
            host: '127.0.0.1',
            port: '2369'
        },
        logging: false
    },

    // ### Testing MySQL
    // Used by Travis - Automated testing run through GitHub
    'testing-mysql': {
        url: 'http://127.0.0.1:2369',
        database: {
            client: 'mysql',
            connection: {
                host     : '127.0.0.1',
                user     : 'root',
                password : '',
                database : 'ghost_testing',
                charset  : 'utf8'
            }
        },
        server: {
            host: '127.0.0.1',
            port: '2369'
        },
        logging: false
    },

    // ### Testing pg
    // Used by Travis - Automated testing run through GitHub
    'testing-pg': {
        url: 'http://127.0.0.1:2369',
        database: {
            client: 'pg',
            connection: {
                host     : '127.0.0.1',
                user     : 'postgres',
                password : '',
                database : 'ghost_testing',
                charset  : 'utf8'
            }
        },
        server: {
            host: '127.0.0.1',
            port: '2369'
        },
        logging: false
    }
};

// Export config
module.exports = config;


Dentro de blog/src/content/themes tenemos que colocar el tema que hayamos elegido (si es que queremos cambiar el tema por defecto), con un simple git clone o arrastrando una carpeta nueva, eso es cosa vuestra.

Y ahora nos toca empezar a trabajar con Vagrant para tener una máquina virtual que nos sirva nuestro nuevo blog.

    $ cd blog
    $ vagrant init

Esto debería crear dentro de tu carpeta blog un nuevo fichero Vagrantfile. Se trata de un fichero de configuración escrito en Ruby. Vamos a reemplazar todo el contenido del fichero por este otro:


Vagrant.configure(2) do |config|
  config.vm.box = "phusion/ubuntu-14.04-amd64"
  config.vm.network "private_network", ip: "192.168.33.10"

  # config.vm.network "forwarded_port", guest: 80, host: 8080
  # config.vm.network "public_network"
  # config.vm.synced_folder "../data", "/vagrant_data"

  config.vm.provision "docker" do |d|
    d.pull_images "jwilder/nginx-proxy"
    d.pull_images "dockerfile/ghost"

    d.run "jwilder/nginx-proxy",
      daemonize: true,
      args: "-p 80:80 -v /var/run/docker.sock:/tmp/docker.sock"

    d.run "dockerfile/ghost",
      daemonize: true,
      args: "-P -e VIRTUAL_HOST=myblog.dev,www.myblog.dev -e NODE_ENV=development -v /vagrant/src:/ghost-override --name blog",
      auto_assign_name: false
  end
end


Sin entrar en detalles de todo lo que significa cada punto del fichero, se trata de crear una máquina virtual con una base de Ubuntu 14.04, con IP 192.168.33.10 y que cuando esté completamente arrancada tendrá dos containers corriendo:

  • jwilder/nginx-proxy: que es nuestro proxy inverso Nginx, pero con la peculiaridad de que podremos dar de alta nuevos sites solo usando variables de entorno.

  • dockerfile/ghost: imagen oficial de Ghost.

La parte más importante de este fichero es la línea donde se definen los argumentos con los que ejecutar la imagen de Docker.

-P -e VIRTUAL_HOST=myblog.dev,www.myblog.dev -e NODE_ENV=development -v /vagrant/src:/ghost-override --name blog

En ella estamos mapeando la carpeta dentro de la máquina virtual /vagrant/src a la carpeta dentro del container /ghost-override que será la que usa la imagen de Ghost para crear la BBDD y cargar nuevos temas. Si no lo hicieramos así, cada vez que paráramos el container de Ghost perderíamos todos los datos. Por último, le estamos indicando a la imagen de Nginx, mediante las variables de entorno VIRTUAL_HOST, que queremos que todas las peticiones que llegan al server dirigidas a myblog.com sean redirigidas a la imagen de Ghost.

Ahora solo resta lanzar Vagrant para que la máquina virtual esté activa.

    $ vagrant up --provision

Consejo: Si quieres tener una url chula de tu entorno de dev edita el fichero /private/etc/hosts y al final pon una línea como: 192.168.33.10 myblog.dev

De modo que, si todo ha ido bien, deberías poder ir a tu navegador, escribir myblog.dev y tener tu nuevo blog vivito y coleando frente a ti.

Hasta aquí la primera parte de la serie. Pronto publicare la segunda donde explicaré cómo montar el entorno de prod. y montar un sistema súper simple de deploy.

Fuentes:

Suscríbete a mi lista de correo

* Campos obligatorios