> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/es/getting-started/docker.md).

# Docker

## Docker

### Comprobar que Docker está instalado correctamente

> **NOTE:** Dispositivos Apple M1: en el momento de redactar este documento existen algunos problemas en dispositivos Apple M1 y en algunos dispositivos ARM64/ARMv8. Consulte [el foro de PowerShell Universal](https://forum.devolutions.net/product/powershell-universal) antes de continuar.

#### Docker

Ejecute el siguiente comando para confirmar que Docker está instalado:

```
docker version
```

Salida de ejemplo:

```
Client: Docker Engine - Community
 Version:           23.0.1
 API version:       1.42
 Go version:        go1.19.5
 Git commit:        a5ee5b1
 Built:             Thu Feb  9 19:47:01 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          23.0.1
  API version:      1.42 (minimum version 1.12)
  Go version:       go1.19.5
  Git commit:       bc3805a
  Built:            Thu Feb  9 19:47:01 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.18
  GitCommit:        2456e983eb9e37e47538f59ea18f2043c9a73640
 runc:
  Version:          1.1.4
  GitCommit:        v1.1.4-0-g5fd4c4d
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

```

#### Docker Compose

Docker Compose v1 utiliza el comando `docker-compose`. A partir de junio de 2023, finaliza el soporte para Docker Compose v1.

Docker Compose v2 utiliza el comando `docker compose`.

Si utiliza Docker Compose v1, ajuste los comandos según corresponda. Puede encontrar más información sobre Docker Compose [aquí](https://docs.docker.com/compose/).

Ejecute uno de los siguientes comandos para confirmar que Docker Compose está instalado:

Docker Compose v1:

```
docker-compose version
```

Docker Compose v2:

```
docker compose version
```

Salida de ejemplo:

```
Docker Compose version v2.16.0
```

#### Un Hello-World de Docker

Para asegurarse de que Docker puede descargar y ejecutar imágenes de contenedor, ejecute el siguiente comando:

```
docker run hello-world
```

Salida de ejemplo:

```
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:ffb13da98453e0f04d33a6eee5bb8e46ee50d08ebe17735fc0779d0349e889e9
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/
```

### Instalación

### Usar el contenedor precompilado

Para ejecutar PowerShell Universal, utilice la imagen de contenedor proporcionada. La imagen de Docker está disponible en [Docker Hub](https://hub.docker.com/r/ironmansoftware/universal).

La versión precompilada admite tanto las funciones gratuitas como las de pago de PowerShell Universal.

Inicie el contenedor descargando la imagen y ejecutando después un contenedor con el puerto predeterminado enlazado.

#### Ejecutar una imagen básica

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 devolutions/powershell-universal
```

#### Presentar una imagen en un puerto diferente

Si el puerto 5000 no está disponible en su host, cambie a otro puerto.

p. ej., presentar en el puerto 80

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 80:5000 devolutions/powershell-universal
```

#### Montar un volumen

El comando `docker run` le permite montar un volumen para almacenamiento persistente. Monte el volumen en la carpeta /root.

**Montar un volumen en un contenedor en Windows**

El siguiente comando monta la carpeta `C:\docker\volumes\PSU` en `/root` de su contenedor:

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 -v C:\docker\volumes\PSU:/root devolutions/powershell-universal 
```

**Montar un volumen en un contenedor en Mac y Linux**

El siguiente comando monta la carpeta `/docker/volumes/PSU` en `/root` de su contenedor:

```
docker pull devolutions/powershell-universal
docker run --name 'PSU' -it -p 5000:5000 -v /docker/volumes/PSU:/root devolutions/powershell-universal 
```

#### Detener un contenedor

El siguiente comando elimina un contenedor detenido llamado `PSU`:

```
docker stop PSU
```

#### Eliminar un contenedor

El siguiente comando detiene un contenedor llamado `PSU`:

```
docker rm PSU
```

La marca `--force` puede eliminar un contenedor en ejecución:

```
docker rm --force PSU
```

### Docker Compose

Docker Compose le permite utilizar un fichero de texto yaml para estandarizar su compilación y programar el despliegue (o la compilación) de varios contenedores.

El nombre predeterminado de cualquier fichero de Compose es `docker-compose.yml`. Se recomienda utilizarlo como nombre de su fichero de Compose.

#### Crear un script de Compose para Windows

El siguiente fichero de Compose ejecuta un contenedor de PowerShell Universal en Windows:

```yml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
    volumes:
      - C:\docker\volumes\PSU:/root
```

#### Crear un script de Compose para Mac / Linux

El siguiente fichero de Compose ejecuta un contenedor de PowerShell Universal en Mac y Linux:

```yml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
    volumes:
      - /docker/volumes/PSU:/root
```

#### Iniciar contenedores mediante scripts de Compose

Con un shell de Terminal o PowerShell para Windows. Utilice el comando cd para cambiar el directorio de trabajo al que contiene su script `docker-compose.yml`.

Ejecute el siguiente comando:

```
docker compose up -d
```

Salida de ejemplo:

```
Creating network "PSU_default" with the default driver
Pulling PSU (devolutions/powershell-universal:latest)...
latest: Pulling from devolutions/powershell-universal
7608715873ec: Pull complete
4e66273c6cfb: Pull complete
2649c52300c2: Pull complete
a20175666bc7: Pull complete
65ce93bc0653: Pull complete
Digest: sha256:d7ff98e6197d21070aac325c2efbefa393a4952d2e8ba6b1327dc97824ec4d55
Status: Downloaded newer image for devolutions/powershell-universal:latest
Creating PSU ... done
```

#### Detener contenedores mediante scripts de Compose

Con un shell de Terminal o PowerShell para Windows. Ejecute cd hasta el directorio que contiene su script `docker-compose.yml`.

Ejecute el siguiente comando

```
docker compose down
```

Salida de ejemplo:

```
[+] Running 2/2
 ⠿ Container PSU         Removed                                           0.5s
 ⠿ Network PSU_default   Removed                                           0.4s
```

#### Uso de variables de entorno y persistencia de SQL

Puede añadir variables de entorno a sus scripts de Compose. A continuación se muestra un ejemplo de:

* Establecer un nombre de nodo
* Añadir persistencia de SQL
* Añadir una cadena de conexión de SQL

```yaml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
      - Plugins__0=SQL
      - Data__ConnectionString=Data Source=sql1.domain.com;Initial Catalog=PSUTicketBridge;User Id=psu_ticketbridge_dbo;Password=Password123;TrustServerCertificate=True;Trusted_Connection=True;integrated security=false;
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

#### Uso de variables de entorno y persistencia de PostgreSQL

Puede añadir variables de entorno a sus scripts de Compose. A continuación se muestra un ejemplo de:

* Establecer un nombre de nodo
* Añadir persistencia de PostgreSQL
* Añadir una cadena de conexión de PostgreSQL

```yaml
version: "5.2.1"
services:
  PSU:
    container_name: PSU
    image: devolutions/powershell-universal:latest
    ports:
      - 5000:5000
    restart: unless-stopped
    environment:
      - TZ=Europe/London
      - Plugins__0=PostgreSQL
      - Data__ConnectionString=Host=PGhostname; Database=PGdatabase; User Id=PGusername; Password=PGpassword!;Port=5432
      - NodeName=mynodename
    volumes:
      - /docker/volumes/PSU:/root
```

### Crear un contenedor personalizado

Si desea crear más funciones, modificar o codificar de forma fija variables de entorno en su contenedor, cree un `Dockerfile`

> ***NOTA:*** Los Dockerfile distinguen entre mayúsculas y minúsculas y deben empezar con una «D» mayúscula.

Para crear una imagen de Docker que pueda conservar los datos de Universal, cree un dockerfile como el siguiente.

Este Dockerfile expone el puerto 5000, crea un volumen /data, establece variables de entorno de configuración para almacenar el repositorio y la base de datos de Universal en el volumen y, a continuación, establece Universal.Server como punto de entrada del contenedor.

#### Escribir un script de Dockerfile para Linux

```docker
FROM devolutions/powershell-universal:latest
LABEL description="Universal - The ultimate platform for building web-based IT Tools" 

EXPOSE 5000
VOLUME ["/home/data"]
ENV Data__RepositoryPath /home/data/Repository
ENV Data__ConnectionString Data Source=/home/data/database.db
ENV UniversalDashboard__AssetsFolder /home/data/UniversalDashboard 
ENV Logging__Path /home/data/logs/log.txt
ENTRYPOINT ["./Universal/Universal.Server"]
```

#### Crear un contenedor

Desde la ruta que aloja su Dockerfile, ejecute el siguiente comando:

```
docker build . --tag=universal-persistent
```

#### Windows

```docker
FROM devolutions/powershell-universal:5.0.0-windowsservercore-1809
LABEL description="Universal - The ultimate platform for building web-based IT Tools" 

EXPOSE 5000
VOLUME ["C:/data"]
ENV Data__RepositoryPath C:/data/Repository
ENV Data__ConnectionString Data Source=C:/data/database.db
ENV UniversalDashboard__AssetsFolder C:/data/UniversalDashboard 
ENV Logging__Path C:/data/logs/log.txt
ENTRYPOINT ["C:/ProgramData/Universal/Universal.Server.exe"]
```

Ejecute una compilación con el comando build:

```
docker build . --tag=universal-persistent
```

Inicie el contenedor de Docker con el comando run y asegúrese de especificar el volumen que se debe montar:

```
docker run -it --name powershelluniversal --mount source=psudata,target=/home/data --rm -d  -p 5000:5000/tcp universal-persistent:latest
```

#### SQL

Para utilizar la persistencia de SQL, defina el plugin y la cadena de conexión de la siguiente manera:

```
ENV Data__ConnectionString=Data Source=ServerName; Initial Catalog=DatabaseName; Integrated Security=SSPI;
ENV Plugins:0=SQL
```

#### PostgreSQL

Para utilizar la persistencia de PostgreSQL, defina el plugin y la cadena de conexión de la siguiente manera:

```
ENV Data__ConnectionString=Host=PGhostname; Database=PGdatabase; User Id=PGusername; Password=PGpassword!;Port=5432
ENV Plugins:0=PostgreSQL
```

### Zonas horarias

Para admitir correctamente las zonas horarias en Linux al programar trabajos, incluya el paquete `tzdata` en su dockerfile junto con una variable de entorno que especifique la zona horaria del servidor.

```
ENV TZ Europe/Amsterdam
RUN apt-get install -y tzdata
```

## Etiquetas

Publicamos las siguientes etiquetas en Docker Hub:

* latest - Versión actual con Ubuntu LTS
* 2026.x-\<OS>-\<PS> - Versión de producción con el sistema operativo y la versión de PS especificados
* 2026.x-modules - Versión de producción actual en Ubuntu LTS con módulos AZ seleccionados instalados
* 4.x-\<OS>-\<PS> - Versión de producción actual 4 con las versiones de sistema operativo y PS especificadas

### Módulos incluidos

Las imágenes de contenedor con módulos incluyen los siguientes módulos:

* Az.Accounts
* Az.Compute
* Az.KeyVault
* Az.Resources
* Invoke-SqlCmd2

## Resumen

Este «Cómo empezar» básico le permite comenzar a ejecutar o crear contenedores de PSU. Esta sección de referencias enlaza todas las fuentes de los comandos:

## Referencias

### Ejecutar contenedores

<https://docs.docker.com/engine/reference/commandline/run/>

<https://docs.docker.com/engine/reference/commandline/stop/>

<https://docs.docker.com/engine/reference/commandline/rm/>

<https://docs.docker.com/compose/>

### Crear contenedores

<https://docs.docker.com/engine/reference/commandline/build/>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/es/getting-started/docker.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
