David Bohm

Hay dos frases que definen mi manera de pensar:
Realmente no hemos prestado mucha atención al pensamiento como un proceso; hemos participado en pensamientos, pero sólo hemos prestado atención al contenido, no al proceso.
La capacidad de percibir o pensar de manera diferente es más importante que el conocimiento adquirido.
Ambas son de David Bohm.
Mostrando entradas con la etiqueta Docker. Mostrar todas las entradas
Mostrando entradas con la etiqueta Docker. Mostrar todas las entradas

miércoles, 18 de mayo de 2022

Instalando Docker Desktop en Fedora 36

Una vez que te acostumbras a hacerlo todo con comandos, la verdad es que resulta hasta cómodo, pero es verdad que el usuario que no es conocedor de la terminal, docker y ciertas peculiaridades de este mundillo puede sufrir bastante.

Para quien lo ha utilizado en entorno Windows, docker se instala con una versión de escritorio que te lo hace mas sencillo, y esta versión de escritorio al fin ha llegado a Linux.

Vamos a la página oficial de docker, sigamos las instrucciones y veamos como instalarlo en Fedora 36:

Lo primero será desinstalar docker y docker-compose si ya lo tenemos como es mi caso:

   # dnf remove docker docker-compose

Instalamos el repositorio:

   # dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo

Descargamos el paquete .rpm de la última versión que tengamos en la página oficial de docker, actualmente la versión 4.8.1, y realizamos la instalación:

   # dnf install ./docker-desktop-4.8.1-x86_64.rpm

Lo buscamos en gnome y lo lanzamos...ya tenemos nuestra aplicación de escritorio para gestionar los dockers.

SaluDOS

domingo, 28 de marzo de 2021

Perdiendo el miedo a generar archivos docker-compose.yml

Todavía hay muchisima referencia en internet a dockers en los que solo se muestra el comando largo y complejo de una línea para levantar un contenedor.

Docker-compose nos ayuda a levantar y parar los contenedores de una forma ágil, habiendo definido previamente todos los parámetros y sin tanto lio como lanzando un línea gigantesca de parámetros en la que si nos hemos confundido tenemos que andar reeditando de malas maneras.

Para instalar docker-compose lanzamos el comando:

   # apt install docker-compose -y

Con docker-compose, solo tenemos que generar un directorio, meter dentro un archivo llamado docker-compose.yml, si está bien contruido, en esa misma ruta lanzamos:

   # docker-compose up

Esto nos mostrará que hace el contenedor y sus logs. Podemos pulsar ctrl+c para parar la ejecución y el contenedor se parará, si cerramos la terminal también Si queremos que se lance en segundo plano, solo tenemos que incluir el parámetro -d

   # docker-compose up -d

Para revertir lo que acabamos de hacer lanzamos:

   # docker-compose down

Este comando detiene y elimina el contenedor, las redes, los volúmenes y las imágenes creadas por up.

El el archivo yaml tenemos que especificar la versión, para conocerla ejecutamos:

   # docker-compose version

Hay que tener en cuenta que siempre hay retrocompatibilidad, pero es importante especificar la versión correcta y seguir evolucionando con la herramienta.

Para tener mas detalles sobre que versión utilizar, tenemos la documentación oficial:

   https://docs.docker.com/compose/compose-file/

   https://docs.docker.com/compose/compose-file/compose-versioning/

Podríamos seguir revisando todos los parámetros posibles, pero según el título de esta entrada queremos perderle el miedo a generar estos archivos. El camino directo cuando nos encontramos un comando docker para levantar un contenedor, solo tenemos que ir a la siguiente página:

   https://www.composerize.com/

Solo tenemos que introducir el comando y aparecerá el archivo docker-compose definido.

SaluDOS

Doctor Jenkins y Mister Docker en uno solo

Jenkins es un servidor automatizado de integración continua de código abierto. Jenkins es capaz de automatizar y probar las compilaciones de código fuente y muestra los errores que puedan aparecer en este proceso. A través de complementos puede ser ampliado en cuanto a características y funcionalidades añadidas.

Jenkins puede ser montado sobre un docker, esto claramente aligera notablemente los pasos para desplegarlo y es lo que vamos a ver. Eso sí, elegiremos mapear volúmenes para que la instalación sea persistente.

El contenedor que mantiene la comunidad actualmente es: https://hub.docker.com/r/jenkins/jenkins

Y podemos encontrar la documentación ofician en la que nos especifican como montarlo aquí: https://github.com/jenkinsci/docker/blob/master/README.md

Algunos parámetros a tener en cuenta:

   -d --> Para que corra en segundo plano

   -v jenkins_home:/var/jenkins_home --> montamos el volumen para que los datos sean persistentes ante operaciones de parada, reinicio y borrado del docker.

   -p 8080:8080 -p 50000:50000 --> Puertos que debemos mapear entre host y contenedor. Si el puerto 8080 ya lo tenemos ocupado en nuestro host, podríamos mapearlo en otro, por ejemplo: -p 8087:8080

   jenkins/jenkins:lts --> especificamos la imagen que mantiene la comunidad.

 Así que el comando completo quedaría para ejecutarlo:

   # docker run -d -v /var/jenkins_home:/var/jenkins_home -p 8087:8080 -p 50000:50000 jenkins/jenkins:lts

DOCKER-COMPOSE

El fichero docker-compose.yml tendrá el siguiente contenido:

   version: '3.3' 

      services: 

         jenkins: 

            volumes: 

               - '/var/jenkins_home:/var/jenkins_home' 

            ports: 

               - '8087:8080' 

               - '50000:50000' 

            image: 'jenkins/jenkins:lts'

Una vez que el docker está arrancado, podremos ir a http://localhost:8087, habrá que esperar un poco hasta que jenkins esté preparado. Nos solicitará lo siguiente:

Unlock Jenkins

To ensure Jenkins is securely set up by the administrator, a password has been written to the log (not sure where to find it?) and this file on the server:

/var/jenkins_home/secrets/initialAdminPassword

Así que podemos ir a esa ruta en nuestro equipo local, copiar la contraseña e introducirla para poder continuar. Con el siguiente comando obtenemos la contraseña:

    # cat /var/jenkins_home/secrets/initialAdminPassword

Una vez que hemos confirmado que somos administradores los que estamos configurando Jenkins, ya podemos seguir con el siguiente paso, configurar los posibles complementos a instalar.

Para no complicarnos de momento la vida y probarlo, podemos instalar los plugins sugeridos entre los que a día de hoy se encuentran:

Folders
OWASP Markup Formatter
Build Timeout
Credentials Binding
Timestamper
Workspace Cleanup
Ant
Gradle
Pipeline
GitHub Branch Source
Pipeline: GitHub Groovy Libraries
Pipeline: Stage View
Git
SSH Build Agents
Matrix Authorization Strategy
PAM Authentication
LDAP
Email Extension
Mailer
 
Tendremos que definir el usuario administrador y su contraseña, después nos preguntará por la URL que queremos que tenga la instancia, esta URL es la que se ofrecerá a los usuarios de Jenkins. Exactamente dice:
 
Configuracíon de la instancia:
 
La URL de Jenkins se utiliza para proporcionar la URL raíz para los enlaces absolutos a varios recursos de Jenkins. Esto significa que este valor es necesario para el correcto funcionamiento de muchas características de Jenkins, incluyendo las notificaciones por correo electrónico, las actualizaciones de estado de PR, y la variable de entorno BUILD_URL proporcionada a los pasos de construcción.
El valor propuesto por defecto que se muestra no se guarda todavía y se genera a partir de la solicitud actual, si es posible. La mejor práctica es establecer este valor a la URL que se espera que utilicen los usuarios. Esto evitará confusiones al compartir o ver los enlaces.

Lo ideal sería generar una entrada DNS con certificado y que la llamada fuese a un subdominio concreto, de cara a los programadores quedará mucho mas profesional. Para probarlo en nuestro propio equipo lo dejamos así, sin complicaciones.
 
Listo, ya podemos comenzar a trabajar con Jenkins.

SaluDOS

sábado, 27 de marzo de 2021

Gestión de dockers con Portainer

Para la gestión de docker siempre tenemos disponible nuestra amiga la consola de comandos, pero... ¿que tal si podemos utilizar un entorno gráfico?

Portainer nos permite gestionar los dockers a través de un portal web. Se instala en forma de docker y a partir de ahí podrás gestionar todos los dockers locales y remotos. 

Algunos parámetros a especificar:

   -d --> Para que se ejecute en segundo plano (dettach)

   --name portainer --> nombre del contenedor

   --restart always

   -p 9000:9000

   -v /var/run/docker.sock:/var/run/docker.sock --> este volumen es necesario para poder gestionar los dockers locales.

 El comando completo

   # docker run -d --name portainer --restart always -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce

Al acceder a http://localhost:9000, la primera acción será configurar la contraseña de administrador de Portainer.

DOCKER-COMPOSE

El fichero docker-compose.yml tendrá el siguiente contenido:

   version: '3.3' 

   services: 

      portainer-ce: 

         container_name: portainer 

         restart: always 

         ports: 

            - '9000:9000' 

         volumes: 

            - '/var/run/docker.sock:/var/run/docker.sock' 

            - 'portainer_data:/data' 

         image: portainer/portainer-ce

SaluDOS

martes, 23 de marzo de 2021

SQL Server en Linux... tal cual lo estás leyendo!

Está claro que no hay limites cuando se trata de contenedores. Efectivamente, podemos montar un SQL Server con un contenedor en una máquina con Linux, en este caso sobre Debian 10.

Si vamos a Docker Hub, podemos encontrar esta imagen mantenida oficialmente por Microsoft:

   https://hub.docker.com/_/microsoft-mssql-server

Los requerimientos que debemos cumplir:

   - Docker Engine 1.8 o superior

   - Por lo menos 2 GB de memoria RAM

   - ACCEPT_EULA=Y, confirmamos que aceptamos estas condiciones

   - SA_PASSWORD=<contraseña robusta por lo menos 8 caracteres>

   - MSSQL_PID= ID de producto/Nombre de edición. Predeterminado el valor Developer.

Los valores aceptados para especificar la edición que desplegamos en el contenedor son:

   - Developer : Esto ejecutará el contenedor usando la Edición Developer (es el valor por defecto si no se suministra la variable de entorno MSSQL_PID) 

   - Express : Esto ejecutará el contenedor usando la Edición Express

   - Standard : Esto ejecutará el contenedor usando la Edición Standard

   - Enterprise : Esto ejecutará el contenedor usando la Edición Enterprise

   - EnterpriseCore : Esto ejecutará el contenedor usando la edición Enterprise Core 

Tenemos que tener presente que estamos aceptando el EULA al lanzar estos comandos, así que vaya por delante que tenemos que cumplir las condiciones de licenciamiento con Microsoft. Por ello podemos utilizar SQL Sever 2017 para entornos de desarrollo y SQL Server Express para entornos de producción.

Hay que tener en cuenta que la versión Express tiene varias limitaciones en la memoria máxima utilizada de 1 GB por el motor de base de datos, 1 MB de caché de buffer máximo, uso máximo de 1 socket y 4 cores de CPU y la limitación de 10 GB en el tamaño de base de datos. No tiene limite en el número de usuarios concurrentes.

Para lanzar un contenedor con una instancia de la última versión de SQL Server:

   # docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=Pa$$w0RD' -p 1433:1433 -d mcr.microsoft.com/mssql/server:2017-latest

Para lanzar un contenedor con una instancia de la versión Express:

   # docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=Pa$$w0RD' -e 'MSSQL_PID=Express' -p 1433:1433 -d mcr.microsoft.com/mssql/server:2017-latest-ubuntu 

Una vez lanzada la instancia, solo tenemos que abrir dbeaver, seleccionar una nueva conexión a SQL Server y rellenar los datos:

   - Servidor: localhost

   - Puerto: 1433

   - Database/Schema: Master 

   - Autenticación: SQL Server Authentication

   - Usuario: sa

   - Contraseña: Pa$$w0RD

Quizás haya que esperar un poco a que establezca la conexión y ya podemos trastear con SQL Server, crear una base de datos, tablas, etcétera. 

DOCKER-COMPOSE

Para la versión SQL Express el archivo docker-compose.yml tendría:

   version: '3.3' 

   services: 

      run: 

         environment: 

            - ACCEPT_EULA=Y 

            - SA_PASSWORD=Pa$$w0RD 

            - MSSQL_PID=Express 

         ports: 

            - '1433:1433' 

         image: run

SaluDOS

lunes, 22 de marzo de 2021

Qucs simulando circuitos electrónicos

Quite Universal Circuit Simulator, en su abreviatura: Qucs, es un simulador integrado de circuitos que utiliza una interfaz gráfica para introducir los componentes que forman el circuito y realizar simulaciones. 

Permite la simulación: en corriente continua, alterna, análisis paramétrico, análisis de balance de armónicos, análisis de ruido, etcétera. Además presenta una interfaz sencilla y simple de manejar. 

Su página web:  http://qucs.sourceforge.net/

Para utilizarlo de forma sencilla sobre cualquier distribución linux, vamos a utilizar la opción de hacerlo a través de un contenedor.

Docker: https://hub.docker.com/r/qucs/qucs

Como especifican desde el docker oficial, para ejecutar el programa solo tenemos que ejecutar la siguiente línea:

   # docker run --rm \ --volume /tmp/.X11-unix:/tmp/.X11-unix \ --volume ~/workspace:/home/.qucs \ qucs/qucs

Automáticamente se abrirá la aplicación en una ventana con interfaz gráfica.

DOCKER-COMPOSE

El contenido del archivo docker-compose.yml será:

   version: '3.3' 

   services: 

      qucs: 

         volumes: 

            - '/tmp/.X11-unix:/tmp/.X11-unix' 

            - '~/workspace:/home/.qucs' 

         image: qucs/qucs

SaluDOS

viernes, 5 de marzo de 2021

Instalar docker-compose en CentOS 7

Para instalar docker-compose en un servidor con CentOS 7 tenemos que seguir los siguientes pasos:

Descargamos la última versión que podemos encontrar en:  https://github.com/docker/compose/releases/

En estos momentos vemos que la última versión es la 1.28.5. La descargamos introduciendo la versión adecuada que tenemos instalada mediante uname y lo llevamos a la ruta adecuada, todo en una misma línea:

   # curl -L "https://github.com/docker/compose/releases/download/1.28.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Añadimos permiso de ejecución:

   # chmod +x /usr/local/bin/docker-compose

Comprobamos $PATH, queremos poder lanzar docker-compose desde cualquier ruta en la que nos encontremos:

   # echo $PATH

Añadimos la ruta a $PATH si no contiene la ruta donde está docker-compose:

   # export PATH="/usr/local/bin:$PATH"

Comprobamos la versión:

   # docker-compose --version

SaluDOS
 

domingo, 28 de febrero de 2021

Instalar GitLab con docker

GitLab además de su versión en la nube puede ser instalado en un servidor o máquina virtual. Pero otra opción muy interesante es la de desplegarlo en un contenedor.

El docker que vamos a utilizar es el oficial de GitLab y en concreto la versión CE (Community Edition):

    https://hub.docker.com/r/gitlab/gitlab-ce/

La documentación oficial la podemos encontrar en:

   https://docs.gitlab.com/omnibus/docker/

Verás que trata sobre la versión Enterprise, pero como indican mas abajo, solo tienes que sustituir gitlab-ee por  gitlab-ce en todos los comando propuestos.

Para correr el docker de GitLab, tendremos que especificar los siguientes parámetros:

   -d --> Para ponerlo en segundo plano (dettach)

   -p 443:443 --> Puerto 443 en el docker y el correspondiente en nuestro equipo

   -p 80:80

   -p 22:22

   --name gitlab --> Nombre del docker

   --restart always --> reiniciará ante errores

   -v /srv/gitlab/config:/etc/gitlab 

   -v /srv/gitlab/logs:/var/log/gitlab

   -v /srv/gitlab/data:/var/opt/gitlab

Para desplegar este docker solo debemos lanzar este comando:

   # docker run -d -p 443:443 -p 80:80 -p 22:22 --name gitlab --restart always -v /srv/gitlab/config:/etc/gitlab -v /srv/gitlab/logs:/var/log/gitlab -v /srv/gitlab/data:/var/opt/gitlab gitlab/gitlab-ce

Es posible que cuando vayamos a acceder a http://localhost obtengamos una respuesta similar a: 502 - Whoops, GitLab is taking too much time to respond. Debemos dejar pasar un rato, hasta que GitLab arranque completamente.

Vamos a ver como cambiar la contraseña de root, son pocos pasos y nos permite repetir la operación siempre que queramos. Lo primero nos conectamos al docker de forma interactiva:

   # docker exec -it gitlab bash

Una vez dentro del contenedor, ejecutamos:

   # gitlab-rails console -e production

Tendremos que esperar a que vuelva a aparecer el prompt y ejecutamos:

   > user = User.where(id: 1).first

   > user.password = 'ContraseñaNueva'

   > user.password_confirmation = 'ContraseñaNueva'

   > user.save

   > exit

Salimos de la consola del docker:

   # exit

Y ya podemos entrar a http://localhost de nuevo e iniciar sesión con el usuario root y la nueva contraseña que hemos especificado anteriormente. A partir de ahí pura esencia GitLab!!!

DOCKER-COMPOSE

El fichero docker-compose.yml deberá contener:

   version: '3.3' 

      services: 

         gitlab-ce: 

            ports: 

               - '443:443' 

               - '80:80' 

               - '22:22' 

            container_name: gitlab 

            restart: always 

            volumes: 

               - '/srv/gitlab/config:/etc/gitlab' 

               - '/srv/gitlab/logs:/var/log/gitlab' 

               - '/srv/gitlab/data:/var/opt/gitlab' 

            image: gitlab/gitlab-ce

SaluDOS

domingo, 21 de febrero de 2021

Montar un docker mysql y conectarse desde dbeaver

VERSIÓN

Antes de montar el docker de mysql, es mejor revisar este enlace y decidir la versión que queremos utilizar:

https://hub.docker.com/_/mysql

Actualmente los dockers soportados son las siguientes versiones de mysql:

   8.0.23   8.0.8   latest

   5.7.33   5.7   5

   5.6.51   5.6

Además vamos a tener la precaución de que los datos sean persistentes. Una vez que se elimine el docker, podremos volver a levantarlo y tendremos nuestras bases de datos intactas.

CREACIÓN DEL DOCKER

Veamos que parámetros vamos a utilizar para levantar el docker, algunos los especificaremos pero son opcionales.

   -d --> Modo en segundo plano (detached)

   --rm --> Cuando paremos el contenedor automáticamente se eliminará

   --name mysql --> Nombre del docker

   -e --> Sirve para pasar al docker una variable de entorno, en este contenedor le vamos a especificar la contraseña del usuario root. seguido de este parámetro especificamos la variable y su valor:

   MYSQL_ROOT_PASSWORD=Pa$$w0rD

   -p 3306:3306 --> Puerto 3306 en el equipo y el correspondiente en el docker

   -v mysql_data:/var/mysql --> Ruta local del equipo y la correspondiente en el docker, esto hará que los datos se guarden en el equipo local y sean persistentes siempre  que especifiquemos la misma configuración del volumen.

   mysql:latest --> última versión del docker de mysql en el repositorio oficial Docker Hub. Si quisieramos una versión concreta, podriamos especificarla:

      mysql:5.7.33

El comando completo sería:

   # docker run -d --rm --name mysql -e MYSQL_ROOT_PASSWORD=Pa$$w0rD -p 3306:3306 -v mysql_data:/var/mysql mysql

Comprobamos que el docker está funcionando:

   # docker ps -a

DOCKER-COMPOSE 

El fichero docker-compose.yml tendría el siguiente contenido:

   version: '3.3' 

   services: 

      mysql: 

         container_name: mysql 

         environment: 

            - MYSQL_ROOT_PASSWORD=Pa$$w0rD 

         ports: 

            - '3306:3306' 

         volumes: 

            - 'mysql_data:/var/mysql' 

         image: mysql

CONEXIÓN DESDE DBEAVER

Para conectarnos a la base de datos que tenemos en un contenedor en nuestro propio equipo, creamos una nueva conexión, seleccionamos mysql y especificamos los datos básicos:

   - Server Host: localhost

   - Port: 3306

   - Nombre de usuario: root

   - Contraseña: Pa$$w0rD

Al finalizar podremos realizar la conexión. Es posible que aparezca algún error en la conexión debido a un parámetro mal configurado. Tanto al crear la conexión como al editarla, en la pestaña Driver Properties podremos reconfigurar una infinidad de parámetros y su valor en la conexión.

Si la conexión no la realizamos desde el mismo equipo que tiene el docker, hay que tener en cuenta que para conexiones remotas tendremos que abrir correctamente los puertos en el firewall del equipo que contiene el contenedor de mysql.

SaluDOS

miércoles, 3 de febrero de 2021

Instalar openVAS con docker

OpenVAS es una suite que permite realizar el escaneado y la gestión vulnerabilidades.

Está claro que podemos tenerlo integrado en una distribución tipo Kali Linux para realizar trabajos de auditorias de seguridad o utilizarlo desde un gestor de eventos de seguridad (SIEM) como OSSIM.

Pero... ¿Qué tal si lo instalamos y utilizamos desde un docker?

Parece una idea atractiva, podemos desplegarlo, utilizarlo, eliminarlo en cualquier momento sin entrar a instalaciones o parametrizaciones complicadas.

El docker que vamos a utilizar y que yo he probado está en:

    https://hub.docker.com/r/atomicorp/openvas

Para correr el docker de openVAS, tendremos que especificar los siguientes parámetros:

   -d --> Para ponerlo en segundo plano (dettach)

   -p 443:443 --> Puerto 443 en el docker y el correspondiente en nuestro equipo

   --name openvas --> Nombre del docker

Desplegar este docker es así de sencillo, solo con este comando:

   # docker run -d -p 443:443 --name openvas atomicorp/openvas

Si queremos actualizar las Network Vulnerability Tests (NVT), es decir, las pruebas de vulnerabilidades de red, podríamos lanzar:

   # docker run -d -p 443:443 -e OV_UPDATE=yes --name openvas atomicorp/openvas

Una vez que lo tengamos corriendo, solo hay que ir a un navegador e introducir la dirección web que nos conectaría a este servicio:

   https://localhost

Obviamente hay que asegurarse de que el puerto 443 está libre, si no siempre podemos elegir otro.

DOCKER-COMPOSE

El fichero docker-compose.yml deberá contener:

   version: '3.3' 

   services: 

      openvas: 

         ports: 

            - '443:443' 

         environment: 

            - OV_UPDATE=yes 

         container_name: openvas 

         image: atomicorp/openvas

SaluDOS

lunes, 25 de enero de 2021

Instalar Filebrowser con docker

Filebrowser es un proyecto muy interesante, permite mapear un directorio en un  equipo y transformarlo en una página web desde la que podremos manejar los directorios y archivos, subir, bajar, eliminar contenido, etcétera.

El proyecto se encuentra en:

   https://github.com/filebrowser/

El primer paso será crear el directorio donde trabajará Filebrowser de forma local en el equipo que contenga el docker:

   # mkdir /fbsrv 

Una alternativa interesante sería no crear un directorio específico y utilizar por ejemplo /home/nombredeusuario, la ruta de nuestro home, de esta forma accederemos directamente a todos nuestros archivos en modo web.

Podemos usar cualquier puerto, pero antes nos aseguramos de que el puerto que vamos a utilizar, en este ejemplo el 8080, está libre en el equipo que contendrá el docker, para ello ejecutamos:

   # lsof -i -P -n | grep 8080

Para correr el docker de filebrowser, tendremos que especificar los siguientes parámetros:

   --name Filebrowser --> Nombre del docker

   --restart always --> Si tiene algun error que reinicie siempre

   -p 8080:80 --> Puerto 8080 en el equipo y el correspondiente en el docker

   -v /fbsrv:/srv --> Ruta local del equipo y la correspondiente en el docker

   -e TZ="Europe/Madrid" --> En nuestro caso el huso horario es este

   filebrowser/filebrowser:latest --> última versión del docker de filebrowser 

El comando para bajar la imagen y correr el docker quedaría algo como esto, dependiendo de si necesitamos variar algún parámetro:

   # docker run -d --name Filebrowser --restart always -p 8080:80 -v /fbsrv:/srv -e TZ="Europe/Madrid" filebrowser/filebrowser:latest

El usuario administror por defecto es: 

   Usuario: admin

   Contraseña: admin

Accedemos a la página web de Filebrowser. El primer paso a realizar siempre debe ser cambiar la contraseña del usuario admin y ya de paso podemos cambiar el idioma en el punto de menú Settings.

   http://localhost:8080 

Si mapeamos una ruta del tipo /home/nombredeusuario, que contenga archivos ocultos, será conveniente en settings activar la opción: Hide dotfiles

Para parar y eliminar el docker:

   # docker stop Filebrowser

   # docker rm Filebrowser

Recuerda que aunque elimines el docker, toda la información que hayas manejado seguirá estándo en local en el equipo. Eso si, tendremos que volver a poner la contraseña de admin si volvemos a lanzarlo.

DOCKER-COMPOSE

El fichero docker-compose.yml tendrá el siguiente contenido:

   version: '3.3' 

   services: 

      filebrowser: 

         container_name: Filebrowser 

         restart: always 

         ports: 

            - '8080:80' 

         volumes: 

            - '/fbsrv:/srv' 

         environment: 

            - TZ=Europe/Madrid 

         image: 'filebrowser/filebrowser:latest'

SaluDOS