Compare commits

...

10 Commits

  1. 2
      .env.sample
  2. 7
      .gitignore
  3. 34
      Dockerfile
  4. 216
      README.md
  5. 20
      config.json.sample
  6. 11
      docker-compose.yml
  7. 13
      entrypoint.sh
  8. 104
      patches/0001-adds-deploy-command-to-gancio.patch

2
.env.sample

@ -0,0 +1,2 @@
GANCIO_DATA_PATH="./data"
GANCIO_PORT=13120

7
.gitignore vendored

@ -1,6 +1,3 @@
# datos de gancio
db.sqlite
config.json
uploads
user_locale
data
.env

34
Dockerfile

@ -1,4 +1,9 @@
## Docker para COMPILACION de Gancio
## ARGUMENTOS:
## GANCIO_VERSION tag/rama desde la que se construye gancio (defecto: master)
## GANCIO_UID uid (identificador numerico) de la usuaria que ejecutara gancio (defecto: 110)
## Etapa 1: COMPILACION de Gancio
##
## - Descarga codigo de Framagit.org
## - Compila la libreria Gancio
@ -9,7 +14,7 @@ FROM registry.sindominio.net/debian
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates git
# Install Node Latest
# Instalar Node Latest
RUN curl -sL https://deb.nodesource.com/setup_12.x | bash - && \
apt-get install -y nodejs
@ -21,23 +26,28 @@ RUN echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/so
echo "deb https://dl.yarnpkg.com/debian/ stable main" > /etc/apt/sources.list.d/yarn.list && \
curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
# Install Yarn
# Instalar Yarn
RUN apt-get update && \
apt-get install -y --no-install-recommends yarn
# Clonar codigo de Gancio
RUN git clone https://framagit.org/les/gancio.git && \
cd gancio && \
git checkout $GANCIO_VERSION
# Aplicar parches
WORKDIR /opt/gancio
COPY patches patches
RUN git apply patches/*.patch
# Instalar dependencias de desarrollo, compilar y empaquetar
RUN yarn install && \
yarn build && \
yarn pack --filename=gancio.tgz
## Docker para EJECUCION de Gancio
## 2da Etapa: EJECUCION de Gancio
##
## - Usa la libreria Gancio compilada antes
## - Instala todas las dependencias de produccion
@ -49,10 +59,11 @@ FROM registry.sindominio.net/debian
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates git
# Install Node Latest
# Instalar Node Latest
RUN curl -sL https://deb.nodesource.com/setup_12.x | bash - && \
apt-get install -y nodejs
# Copiar y descomprimir el servicio de Gancio compilado en 1ra Etapa
COPY --from=0 /opt/gancio/gancio.tgz ./
RUN tar zxf gancio.tgz && \
@ -61,5 +72,18 @@ RUN tar zxf gancio.tgz && \
WORKDIR /gancio
# Instalar solo las dependencias de produccion y crear symlink para ejecucion
RUN npm install --production && \
ln -s /gancio/server/cli.js /usr/local/bin/gancio
# Crear usuaria gancio para ejecutar el servicio
ARG GANCIO_UID=110
RUN useradd -u $GANCIO_UID -g nogroup gancio
# Compiar el script de entrada del repo y ejecutar
ADD entrypoint.sh /
RUN chmod 750 /entrypoint.sh
ENTRYPOINT [ "/bin/sh", "/entrypoint.sh" ]

216
README.md

@ -1,92 +1,218 @@
# GANCIO for SINDOMINIO
https://gancio.org/install/docker
## Dependencias
El servidor que vaya a ejecutar esta version dockerizada de Gancio necesita contar
con un demonio de Docker, asi como con el binario `docker-compose`.
## Dockerfile
Estas dos dependencias suelen instalarse conjuntamente, como un paquete de las
diferentes distribuciones linux, la [documentacion oficial de Docker][0] nos ayuda a
hacerlo
El original funciona sobre la imagen de docker de node
[0]: https://docs.docker.com/engine/install/
## Inicio Rapido
Si simplemente quieres poner a andar una instancia de Gancio, puedes seguir
los pasos en las secciones [instalacion manual](#instalacion-manual),
[configuracion](#configuracion-del-servicio) y [ejecucion](#ejecucion-de-gancio)
Resumidos quedan asi:
```bash
git clone https://git.sindominio.net/gancio/docker-gancio
cd docker-gancio
mkdir data
touch data/config.json data/db.sqlite
cp .env.sample .env
docker-compose build
docker-compose run --rm gancio "gancio setup --docker --db=sqlite"
docker-compose up -d
```
Si has usado las configuraciones por defecto, Gancio deberia estar disponible
en <http://localhost:13120>
## Instrucciones originales de instalacion
<https://gancio.org/install/docker>
## Construccion del docker para Gancio
El original se basa en la imagen de node disponible en DockerHub
```
FROM node:latest
WORKDIR /
RUN yarn global add gancio
...
```
Nosotros debemos funcionar a través de nuestro Debian en nuestro registry,
asi que adaptamos un poco el Dockerfile al estilo la guía de instalación de GNU/Debian
Nosotros elegimos funcionar a través de nuestro Debian en nuestro registry,
asi que adaptamos el Dockerfile al estilo la [guía de instalación de GNU/Debian][1]
https://gancio.org/install/debian
[1]: https://gancio.org/install/debian
```
FROM registry.sindominio.net/debian as builder
FROM registry.sindominio.net/debian
...
```
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates
Ejecutamos un poroceso de construccion del docker de 2 etapas. En la __1ra
etapa__, clonamos el codigo del repositorio de gancio y compilamos el servicio.
En la __2da etapa__ utilizamos el servicio compilado en la etapa anterior, y
lo instalamos en un docker basado en el debian de SinDominio, e instalamos las
minimas dependencias necesarias para ejecutar el proyecto.
RUN echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list && \
echo "deb https://dl.yarnpkg.com/debian/ stable main" > /etc/apt/sources.list.d/yarn.list
RUN curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
#RUN curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor > /usr/share/keyrings/yarn-archive-keyring.gpg
### Nuevo punto de entrada al docker
Agregamos un script de entrada, `entrypoint.sh`, que se ocupa de
validar la existencia de los datos/variables necesarias para poder ejecutar el
servicio, gestiona la propiedad de los archivos de datos de gancio, e inicia
el servicio como la usuaria `gancio`
# Install Yarn
RUN apt-get update && \
apt-get install -y --no-install-recommends yarn
# Install Node Latest
RUN curl -sL https://deb.nodesource.com/setup_12.x | bash -
RUN apt-get install -y nodejs
### Ejecucion desempoderada
Por razones de seguridad, evitamos ejecutar servicios dentro de los dockers
como usuaria `root`. En este caso, ejecutaremos el servicio como usuaria
`gancio` perteneciente al grupo `nogroup`
WORKDIR /
RUN yarn global add gancio
```
## Instalación
### Parametros disponibles en la construccion del docker
`docker-compose`, al igual que `docker`, nos permite pasar variables de entorno
al proceso de construccion del contenedor, utilizando la opcion
`--build-arg MI_VAR=valor`
Nuestro nuevo proceso de construccion toma los siguientes parametros, ambos
opcionales:
* `GANCIO_VERSION`, contiene el nombre de la rama o tag de git que queremos
utilizar _(valor por defecto: `master`)_
* `GANCIO_UID`, contiene el indicador numerico asociada a la usuaria `gancio`
que ejecutara el servicio dentro del docker _(valor por defecto: `110`)_
Seguimos los pasos de Gancio.
Primero, descargamos este repo:
## Instalacion Manual
Si estamos instalando Gancio manualmente, podemos seguir los pasos de la
docuemntacion de Gancio. Este proceso requere intervencion de la usuaria que
debe responder a un cuestionario durante la etapa de Setup.
Primero, descargamos este repo
```
git clone https://git.sindominio.net/siroco/docker-gancio
git clone https://git.sindominio.net/gancio/docker-gancio
```
Accedemos a la carpeta creada:
Accedemos a la carpeta creada
```
cd docker-gancio
```
Ejecutamos los siguiente comandos para crear los ficheros básicos para la instalación
Creamos los ficheros básicos para la instalacion y configuracion del servicio:
```
touch config.json db.sqlite
mkdir user_locale
mkdir data
touch data/config.json data/db.sqlite
cp .env.sample .env
```
Y luego a buildear y configurar
Luego a buildear
```
docker-compose build
```
Seguimos los pasos del SETUP de Gancio
Y por ultimo, respondems a las preguntas del instalador
```
docker-compose run --rm gancio gancio setup --docker --db=sqlite
docker-compose run --rm gancio "gancio setup --docker --db=sqlite"
```
Y supongo que tras esto, podemos hacer un
## Instalacion Automatica
En este caso, nos interesa desplegar Gancio sin intervencion de una usuaria.
Queremos:
* evitar el questionario de setup
* proveer datos necesarios via `config.json` o variables de entorno
Necesitamos, entonces, un archivo `config.json` con la configuracion de la
instancia. Nuestro repositorio incluye un archivo `config.json.sample` a modo
de ejemplo. Te recomendamos copiar este archivo dentro del directorio de datos
que vayas a utilizar para Gancio y editarlo con los datos de tu instancia
```bash
git clone https://git.sindominio.net/gancio/docker-gancio
cd docker-gancio
mkdir data
cp config.json.sample data/config.json
```
docker-compose up -d
Al editar el archvio, los datos que nos interesa cambiar en este archivo son
- `title`, nombre de nuestra instancia de Gancio
- `baseurl`, url publica de este servicio
- `secret`, sal para los datos encryptados en la bbdd. puedes generar uno
nuevo con `cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w ${1:-24} | head -n 1`
- `admin_email`, email de la cuenta de administradora (se usa para acceder al
gestionar el servicio)
- `admin_pass`, clave de acceso para la cuenta de administradora. _SE ELIMINA
AUTOMATICAMENTE DEL FICHERO AL CREAR LA CUENTA_
- `smtp`, si se desea enviar correos, modificar a los datos de vuestro
servidor de SMPT
No modifiques los siguientes datos/secciones, ya que modificarian la forma en
que Gancio funciona dentro del docker y podria romper el servicio si no estas
segura de lo que haces ;)
- `server`
- `upload_path`
- `db`
### Cuenta de administradora
Esta cuenta solo se creara en el caso de iniciar una nueva instancia de
Gancio, sin datos.
Si estamos re-iniciando una instancia existente, estos datos seran ignorados
y se deberan conocer los datos de la cuenta de administradora originales.
Entonces, en una instancia nueva iniciada sin datos, la administradora podra
loguearse utilizando el dato `admin_email` y `admin_pass` informado en el
`config.json`
### Autenticacion para SMTP
Si tu servidor de correos necesita de autenticacion, debemos persistir esta
informacion en la seccion `smtp` del fichero `config.json`
```json
...
"smtp": {
"host": "localhost",
"port": 25,
"auth": {
"user": "<smtp_user>",
"pass": "<smtp_password>"
}
},
...
```
## Configuracion del servicio
Dado que utilizamos `docker-compose` para ejecutar Gancio, aprovecharemos la
posibilidad de definir nuestras variables de entorno en un archivo `.env` que
deberemos mantener en la misma carpeta que nuestro `docker-compose.yml`
Este repositorio contiene un `.env.sample` a modo de ejemplo. Si te valen los
valores por defecto, puedes copiar el archivo `.env.sample` y llamarlo `.env`
```bash
cp .env.sample .env
```
Y a disfrutar de tu servicio de Gancio
### Variables de Despliegue (necesarias en todos los casos)
- `GANCIO_DATA_PATH`, ruta en el host que contiene los datos de Gancio
_(valor por defecto `./data` = subcarpeta `data` en la misma carpeta que
`docker-compose.yml`)_
- `GANCIO_PORT`, puerto del host en el que se expondra el servicio de Gancio
_(valor por defecto `13120`)_
Ahora te toca configurar el ProxyReverse ;)
## TODO
## Ejecucion de Gancio
Llegado este punto, podemos iniciar nuestra intancia
```
docker-compose up -d
```
A ver quien hace un container con PostgreSQL en vez de SQLITE ;)
Y a disfrutar de tu servicio de Gancio \o/

20
config.json.sample

@ -0,0 +1,20 @@
{
"title": "Gancio",
"baseurl": "http://localhost:13120",
"secret": "uw07xdmw2dh0ucnuy6bkwz",
"admin_email": "gancio@localhost",
"smtp": {
"host": "localhost",
"port": 25
},
"server": {
"host": "localhost",
"port": 13120
},
"db": {
"dialect": "sqlite",
"storage": "/opt/gancio/db.sqlite",
"logging": false
},
"upload_path": "/opt/gancio/uploads"
}

11
docker-compose.yml

@ -3,15 +3,10 @@ version: '3'
services:
gancio:
build: .
restart: always
image: gancio:latest
container_name: gancio
command: gancio start --docker --db=sqlite
environment:
- DEBUG=*,-babel,-follow-redirects,-send,-body-parser:*,-express:*,-connect:*,-sequelize:*
command: [ "gancio deploy --docker --db=sqlite --autostart" ]
volumes:
- ./db.sqlite:/opt/gancio/db.sqlite
- ./config.json:/opt/gancio/config.json
- ./uploads:/opt/gancio/uploads
- $GANCIO_DATA_PATH:/opt/gancio
ports:
- "127.0.0.1:13120:13120"
- "127.0.0.1:$GANCIO_PORT:13120"

13
entrypoint.sh

@ -0,0 +1,13 @@
#!/bin/bash
# verifica que exista un archivo de configuracion
[ -f /opt/gancio/config.json ] || { echo 'falta el archivo de configuracion config.json'; exit 1; }
# si no existe, crea la base de datos sqlite
[ -f /opt/gancio/db.sqlite ] || touch /opt/gancio/db.sqlite
# recupera permisos a nombre de la usuaria gancio
chown -R gancio:nogroup /opt/gancio
# ejecuta el Command pasado al docker, como usuaria gancio
su gancio --command="$@"

104
patches/0001-adds-deploy-command-to-gancio.patch

@ -0,0 +1,104 @@
From b2722e244c8249d6cdc3464610fb257e8c80d849 Mon Sep 17 00:00:00 2001
From: matus <matus@enmotoneta.com>
Date: Fri, 4 Jun 2021 16:29:07 +0000
Subject: [PATCH] adds deploy command to gancio
---
server/cli.js | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 67 insertions(+)
diff --git a/server/cli.js b/server/cli.js
index 41005ca2..7148f3e0 100755
--- a/server/cli.js
+++ b/server/cli.js
@@ -305,6 +305,67 @@ async function setup (options) {
process.exit(0)
}
+async function deploy (options) {
+ consola.info('You\'re going to deploy gancio on this machine.')
+
+ // check for mandatory config.json
+ if (firstrun.check(options.config)) {
+ consola.error(` ⚠ MISSING CINFIGURATION: Configuration file "${options.config}" not found!
+ Use "--config <CONFIG_FILE.json>" to specify another path, or generate one running 'gancio setup'`)
+ process.exit(-1)
+ }
+ const config = require(options.config)
+
+ // run migrations on ddbb
+ await run_migrations(config.db)
+
+ const db = require('./api/models')
+ const User = require('./api/models/user')
+ await db.authenticate()
+
+ // if new instance, initialize
+ const users = await User.findAll()
+ if (users.length === 0) {
+ // check for necesary data
+ if (!(config.admin_email && config.admin_pass)) {
+ consola.error(`⚠ MISSING CONFIGURATION: Cannot create Admin account on new deployment
+ Please, specify both 'admin_email' and 'admin_pass' on the config file`)
+ process.exit(-1)
+ }
+
+ // generate a random salt
+ consola.info(`Generate random salt`)
+ config.secret = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15)
+
+ // create admin user
+ const admin = { email: config.admin_email, password: config.admin_pass }
+
+ consola.info(`Create admin with email: ${admin.email}`)
+ await User.create({
+ email: admin.email,
+ password: admin.password,
+ is_admin: true,
+ is_active: true
+ })
+
+ // remove admin password and store salt/secret on config.json
+ delete config.admin_pass
+
+ consola.info(`Save configuration to ${options.config}`)
+ try {
+ fs.writeFileSync(options.config, JSON.stringify(config, null, 2))
+ } catch (e) {
+ consola.warn(` ⚠ ${e}. You can specify configuration path using '--config'`)
+ }
+
+ }
+
+ if ( options.autostart ) {
+ // start gancio using default method
+ start(options)
+ }
+}
+
consola.info(`📅 ${pkg.name} - v${pkg.version} - ${pkg.description}`)
require('yargs')
@@ -323,6 +384,11 @@ require('yargs')
describe: 'Configuration file',
default: '/opt/gancio/config.json'
})
+ .option('autostart', {
+ describe: 'Start gancio service after deploying',
+ default: false,
+ type: 'boolean'
+ })
.coerce('config', config_path => {
const absolute_config_path = path.resolve(cwd, config_path)
process.env.config_path = absolute_config_path
@@ -330,6 +396,7 @@ require('yargs')
})
.command(['start', 'run', '$0'], 'Start gancio', {}, start)
.command('setup', 'Setup a new instance', {}, setup)
+ .command('deploy', 'Deploy a instance from config files', {}, deploy)
.help('h')
.alias('h', 'help')
.epilog('Made with ❤ by underscore hacklab - https://gancio.org')
--
2.31.1
Loading…
Cancel
Save