Construção de Imagem com Servidor HTTP Apache

Crie um diretório de trabalho para o projeto e defina um Dockerfile que utilize CentOS como base, instale o pacote httpd, exponha a porta 80 e inclua um arquivo HTML personalizado.

mkdir -p /opt/servidor-web && cd /opt/servidor-web

cat > Dockerfile << 'EOF'
FROM centos:7
LABEL descricao="Imagem com Apache HTTP Server"
RUN yum -y install httpd
EXPOSE 80
ADD index.html /var/www/html/
ADD entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
CMD ["/entrypoint.sh"]
EOF

Crie o script de inicialização que garante a limpeza de caches e mantém o Apache em primeiro plano, pois o contêiner permanece ativo apenas enquanto o processo de PID 1 estiver em execução:

cat > entrypoint.sh << 'EOF'
#!/bin/bash
rm -rf /run/httpd/*
exec /usr/sbin/apachectl -D FOREGROUND
EOF

echo "Bem-vindo ao servidor Docker" > index.html

Uma alternativa sem script externo é combinar ENTRYPOINT com CMD:

ENTRYPOINT ["/usr/sbin/apachectl"]
CMD ["-D", "FOREGROUND"]

Construa a imagem e inicie o contêiner mapeando a porta do host:

docker build -t webserver:centos7 .

docker run -d -p 8080:80 webserver:centos7

Construção de Imagem com Servidor SSH

Para habilitar acesso remoto via SSH em um contêiner baseado em CentOS, instale os pacotes necessários, configure a senha de root e gere as chaves de autenticação:

mkdir -p /opt/servidor-ssh && cd /opt/servidor-ssh

cat > Dockerfile << 'EOF'
FROM centos:7
LABEL descricao="Imagem com servidor SSH"
RUN yum -y install openssh-server net-tools lsof telnet passwd
RUN echo 'MinhaSenha123' | passwd --stdin root
RUN sed -i 's/#PermitRootLogin yes/PermitRootLogin yes/' /etc/ssh/sshd_config
RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key -N ''
RUN mkdir -p /root/.ssh && chmod 700 /root/.ssh
EXPOSE 22
CMD ["/usr/sbin/sshd", "-D"]
EOF

Construa e execute o contêiner com mapeamento aleatório de portas:

docker build -t sshd-server:centos .

docker run -d -P sshd-server:centos

docker ps -a
# utilize a porta exibida na coluna PORTS
ssh root@localhost -p <porta_mapeada>

Construção de Imagem com Suporte ao Systemd

Contêineres Docker geralmente não executam o systemd por padrão. Para utilizá-lo, é necessário preparar uma imagem que remova serviços desnecessários e monte o cgroup do host:

mkdir -p /opt/systemd-container && cd /opt/systemd-container

cat > Dockerfile << 'EOF'
FROM sshd-server:centos
ENV container=docker
RUN (cd /lib/systemd/system/sysinit.target.wants/ && \
     for f in *; do [ "$f" = "systemd-tmpfiles-setup.service" ] || rm -f "$f"; done) && \
    rm -f /lib/systemd/system/multi-user.target.wants/* && \
    rm -f /etc/systemd/system/*.wants/* && \
    rm -f /lib/systemd/system/local-fs.target.wants/* && \
    rm -f /lib/systemd/system/sockets.target.wants/*udev* && \
    rm -f /lib/systemd/system/sockets.target.wants/*initctl* && \
    rm -f /lib/systemd/system/basic.target.wants/* && \
    rm -f /lib/systemd/system/anaconda.target.wants/*
VOLUME ["/sys/fs/cgroup"]
CMD ["/usr/sbin/init"]
EOF

Inicie o contêiner com privilégios elevados e monte o diretório cgroup em modo somente leitura:

docker build -t systemd-container:centos .

docker run --privileged -dit -P \
  -v /sys/fs/cgroup:/sys/fs/cgroup:ro \
  systemd-container:centos /sbin/init

docker exec -it <container_id> bash
systemctl status sshd

O parâmetro --privileged concede permissões reais de root dentro do contêiner. Sem ele, o usuário root interno é tratado como um usuário comum no host. O parâmetro -v segue a sintaxe -v <dir_host>:<dir_container>:[rw|ro], onde rw permite leitura e escrita e ro restrineg a somente leitura.

Construção de Imagem com Servidor Nginx

Para compilar o Nginx a partir do código-fonte dentro de uma imagem Docker, é necessário instalar as dependências de compilação, copiar o tarball e executar o processo de build:

mkdir -p /opt/servidor-nginx && cd /opt/servidor-nginx
# copie o tarball do nginx para o diretório atual

cat > Dockerfile << 'EOF'
FROM centos:7
LABEL descricao="Imagem com Nginx compilado do fonte"
RUN yum -y install pcre-devel zlib-devel gcc gcc-c++ make
RUN useradd -M -s /sbin/nologin nginx
ADD nginx-1.12.0.tar.gz /usr/local/src/
WORKDIR /usr/local/src/nginx-1.12.0
RUN ./configure \
    --prefix=/usr/local/nginx \
    --user=nginx \
    --group=nginx \
    --with-http_stub_status_module \
    && make && make install
ENV PATH=/usr/local/nginx/sbin:$PATH
EXPOSE 80
EXPOSE 443
RUN echo "daemon off;" >> /usr/local/nginx/conf/nginx.conf
CMD ["/usr/local/nginx/sbin/nginx"]
EOF

Ao adicionar daemon off; ao arquivo de configuração do Nginx, o processo principal permanece em primeiro plano, impedindo que o contêiner seja encerrado prematuramente.

docker build -t nginx-server:centos .

docker run -d -P nginx-server:centos

docker ps -a