USER

A instrução USER em um Dockerfile é usada para especificar o usuário sob o qual os comandos subsequentes serão executados no contêiner. Isso é importante para segurança, pois a execução de processos como o usuário root (o padrão) pode expor o sistema a riscos. Definir um usuário não-root ajuda a minimizar os privilégios e limitar o impacto potencial de falhas de segurança.

Sintaxe Básica

USER <usuário>[:<grupo>]

• usuário: O nome ou o ID do usuário que será usado.

• grupo (opcional): O nome ou o ID do grupo ao qual o usuário pertence. Se não for especificado, o grupo principal do usuário será usado.

Funcionalidades do USER

• Segurança: Executar processos com um usuário de privilégios limitados é uma prática recomendada para reduzir riscos de segurança.

• Personalização: Você pode criar e configurar usuários específicos para diferentes tarefas no contêiner, ajustando permissões conforme necessário.

Exemplos de Uso

Usando um Usuário Não-Root Existente

FROM ubuntu:20.04
USER nobody

Neste exemplo, todos os comandos subsequentes serão executados pelo usuário nobody, que é um usuário padrão de baixíssimo privilégio em sistemas Unix.

Especificando Usuário e Grupo

FROM ubuntu:20.04
USER www-data:www-data

Aqui, o contêiner executará comandos como o usuário www-data do grupo www-data, comum em servidores web como Apache e NGINX.

Criando e Usando um Novo Usuário

FROM ubuntu:20.04
RUN groupadd -r meugrupo && useradd -r -g meugrupo meuusuario
USER meuusuario

Neste exemplo:

• Um novo grupo meugrupo é criado.

• Um novo usuário meuusuario é adicionado e associado ao grupo meugrupo.

• Os comandos subsequentes serão executados pelo usuário meuusuario.

Considerações de Segurança

• Evitar o Uso de Root: Sempre que possível, evite usar o usuário root, especialmente para serviços de longa duração ou expostos ao público. Executar contêineres com privilégios de root aumenta o risco de uma falha de segurança comprometer o sistema host.

• Privilégios Mínimos: Aplique o princípio do menor privilégio. O usuário definido pelo USER deve ter apenas as permissões necessárias para executar a aplicação, minimizando os riscos em caso de comprometimento.

Impacto no Dockerfile

• Instruções Sucessivas: Após definir USER, todas as instruções seguintes (como RUN, CMD, ENTRYPOINT) serão executadas sob esse usuário, até que o USER seja alterado novamente, se necessário.

• Permissões de Arquivos: Se você definir um usuário não-root antes de operações de cópia de arquivos (COPY, ADD), certifique-se de que o usuário tenha as permissões necessárias para acessar e modificar esses arquivos.

Exemplo Avançado

Configuração de um Contêiner para um Serviço Web

FROM nginx:alpine

# Adicionar um usuário e grupo específicos
RUN addgroup -S nginxgroup && adduser -S nginxuser -G nginxgroup

# Definir o usuário para o serviço
USER nginxuser

# Copiar arquivos da aplicação
COPY --chown=nginxuser:nginxgroup . /usr/share/nginx/html

# Expor a porta do serviço
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Neste exemplo:

• Um usuário nginxuser e um grupo nginxgroup são criados.

• O contêiner executa o NGINX como nginxuser.

• Os arquivos da aplicação são copiados com as permissões corretas.

Resumo

• USER define o usuário sob o qual os comandos subsequentes serão executados, aumentando a segurança e controlando os privilégios.

• Evitar Root: Execute processos com um usuário não-root sempre que possível para minimizar riscos de segurança.

• Flexibilidade: Você pode definir e configurar usuários e grupos específicos para diferentes necessidades dentro do contêiner.

Laboratório

FROM ubuntu
RUN apt update && apt install curl --yes

$ docker build -t ubuntu-curl .
[+] Building 0.1s (6/6) FINISHED                             docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 90B                                    0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [1/2] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/2] RUN apt update && apt install curl --yes              0.0s
 => exporting to image                                                 0.0s
 => => exporting layers                                                0.0s
 => => writing image sha256:89d03ff78decdf8c69556521887cbf16c40f52ebf  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s

$ docker container run -it ubuntu-curl /bin/bash
root@be968c94e69b:/#

Na execução do container, o usuário logado é o root que é o super-usuário da distribuição Linux.

Boa prática: criar um usuário para a execução do container

Criação e definição do usuário

FROM ubuntu
RUN apt update && apt install curl --yes

RUN useradd marcelo
USER marcelo

A ordem no Dockerfile é importante, pois em determinados pontos estão sendo executados comandos de atualização, instalação etc.

USER marcelo altera o usuário logado

$ docker build -t ubuntu-curl .
[+] Building 0.4s (7/7) FINISHED                             docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 123B                                   0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [1/3] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/3] RUN apt update && apt install curl --yes              0.0s
 => [3/3] RUN useradd marcelo                                          0.3s
 => exporting to image                                                 0.0s
 => => exporting layers                                                0.0s
 => => writing image sha256:f3848833eef586446dd804729730d866cc728268d  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
$ docker container run -it ubuntu-curl /bin/bash
marcelo@3ce4b3b45ad5:/$

useradd não adiciona uma camada ao filesystem, mas é utilizado como metadado:

$ docker image inspect ubuntu-curl
...
        "Config": {
            "User": "marcelo",
...

COPY com definição do usuário criado

FROM ubuntu
RUN apt update && apt install curl --yes
WORKDIR /app

RUN useradd marcelo
COPY --chown=marcelo:marcelo --chmod=777 ./arquivos/teste.txt .
USER marcelo

$ ls ./arquivos
arquivo.txt  teste.txt
marcelo@Latitude5440:~$ docker build -t ubuntu-curl .
[+] Building 0.5s (10/10) FINISHED                           docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 202B                                   0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [internal] load build context                                      0.0s
 => => transferring context: 67B                                       0.0s
 => [1/5] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/5] RUN apt update && apt install curl --yes              0.0s
 => CACHED [3/5] WORKDIR /app                                          0.0s
 => [4/5] RUN useradd marcelo                                          0.3s
 => [5/5] COPY --chown=marcelo?marcelo --chmod=777 ./arquivos/teste.t  0.0s
 => exporting to image                                                 0.1s
 => => exporting layers                                                0.0s
 => => writing image sha256:9b7bba306cec1e86728e6b0a76d4cd3437c72890d  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
marcelo@Latitude5440:~$ docker container run -it ubuntu-curl /bin/bash
marcelo@d9a9ea82e99c:/app$ ls
teste.txt