Compare commits

..

6 Commits

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

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

3
.gitignore vendored

@ -1,3 +0,0 @@
# datos de gancio
data
.env

@ -1,89 +1,27 @@
## 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)
FROM registry.sindominio.net/debian as builder
## Etapa 1: COMPILACION de Gancio
##
## - Descarga codigo de Framagit.org
## - Compila la libreria Gancio
## - Dependencias: nodejs + yarn
##
FROM registry.sindominio.net/debian
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates git
# Instalar Node Latest
RUN curl -sL https://deb.nodesource.com/setup_12.x | bash - && \
apt-get install -y nodejs
WORKDIR /opt
ARG GANCIO_VERSION=master
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 && \
curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
# 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
## 2da Etapa: EJECUCION de Gancio
##
## - Usa la libreria Gancio compilada antes
## - Instala todas las dependencias de produccion
## - Crea un link en /usr/local/bin/gancio
## - Dependencias: nodejs
##
FROM registry.sindominio.net/debian
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates git
# 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 && \
mv package gancio && \
rm gancio.tgz
apt-get install -y --no-install-recommends ca-certificates
WORKDIR /gancio
RUN echo "deb http://deb.debian.org/debian buster-backports main" >> /etc/apt/sources.list
# 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
RUN apt-get install -y nodejs npm
# Crear usuaria gancio para ejecutar el servicio
ARG GANCIO_UID=110
## Opcion via repos no funciona, posiblmente la version...
#RUN apt-get install -y yarn
RUN useradd -u $GANCIO_UID -g nogroup gancio
RUN npm install -g yarn
# Compiar el script de entrada del repo y ejecutar
ADD entrypoint.sh /
WORKDIR /
RUN chmod 750 /entrypoint.sh
# esto lo hacemos así, pero podemos probar de descagar el código y compilarlo
# nos ofrece algún tipo checksum o firmado para validar que Gancio es el gancio que queremos y no un Gancio manipulado, al descargarlo?
# sí, o por lo menos, un package en yarm tiene su checksum y lo consideran "mega seguro", en el fondo, es un package.json con los módulos a instalar y el repo, más o menos lo mismo que podemos hacer a mano, no?
RUN yarn global add gancio --prod
ENTRYPOINT [ "/bin/sh", "/entrypoint.sh" ]
## por ejemplo
# RUN apt-get install -y git
# RUN git clone https://framagit.org/les/gancio && cd gancio
# RUN yarn --prod
# RUN ./node_modules/.bin/sequelize db:migrate
# RUN yarn dev

@ -1,218 +1,92 @@
# GANCIO for SINDOMINIO
## 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`.
https://gancio.org/install/docker
Estas dos dependencias suelen instalarse conjuntamente, como un paquete de las
diferentes distribuciones linux, la [documentacion oficial de Docker][0] nos ayuda a
hacerlo
## Dockerfile
[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
El original funciona sobre la imagen de docker de node
```
FROM node:latest
...
WORKDIR /
RUN yarn global add gancio
```
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]
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
[1]: https://gancio.org/install/debian
https://gancio.org/install/debian
```
FROM registry.sindominio.net/debian
...
```
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.
FROM registry.sindominio.net/debian as builder
### 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`
RUN apt-get update && \
apt-get install -y --no-install-recommends curl gnupg2 ca-certificates
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
### 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`
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
# Install Yarn
RUN apt-get update && \
apt-get install -y --no-install-recommends yarn
### 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`
# Install Node Latest
RUN curl -sL https://deb.nodesource.com/setup_12.x | bash -
RUN apt-get install -y nodejs
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`)_
WORKDIR /
RUN yarn global add gancio
```
## Instalación
## Instalacion Manual
Seguimos los pasos de Gancio.
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:
Primero, descargamos este repo
```
git clone https://git.sindominio.net/gancio/docker-gancio
git clone https://git.sindominio.net/siroco/docker-gancio
```
Accedemos a la carpeta creada
Accedemos a la carpeta creada:
```
cd docker-gancio
```
Creamos los ficheros básicos para la instalacion y configuracion del servicio:
```
mkdir data
touch data/config.json data/db.sqlite
cp .env.sample .env
```
Ejecutamos los siguiente comandos para crear los ficheros básicos para la instalación
Luego a buildear
```
docker-compose build
touch config.json db.sqlite
mkdir user_locale
```
Y por ultimo, respondems a las preguntas del instalador
Y luego a buildear y configurar
```
docker-compose run --rm gancio "gancio setup --docker --db=sqlite"
docker-compose build
```
Seguimos los pasos del SETUP de Gancio
## 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
```
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>"
}
},
...
docker-compose run --rm gancio gancio setup --docker --db=sqlite
```
Y supongo que tras esto, podemos hacer un
## 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
```
docker-compose up -d
```
### 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`)_
Y a disfrutar de tu servicio de Gancio
Ahora te toca configurar el ProxyReverse ;)
## Ejecucion de Gancio
Llegado este punto, podemos iniciar nuestra intancia
```
docker-compose up -d
```
## TODO
Y a disfrutar de tu servicio de Gancio \o/
A ver quien hace un container con PostgreSQL en vez de SQLITE ;)

@ -1,20 +0,0 @@
{
"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"
}

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

@ -1,13 +0,0 @@
#!/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="$@"

@ -1,104 +0,0 @@
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