One place for hosting & domains

      Utilizar

      Cómo instalar y utilizar Postfix en Ubuntu 20.04


      Justin Ellingwood escribió una versión anterior de este tutorial.

      Introducción

      Postfix es un popular agente de transferencia de correo (MTA) de código abierto que puede usarse para dirigir y entregar correo electrónico en un sistema Linux. Se estima que alrededor del 25 % de los servidores de correo público de Internet cuentan con Postfix.

      En esta guía, se mostrará la manera de instalar y configurar Postfix en un servidor de Ubuntu 20.04. Luego, comprobará que Postfix puede dirigir correctamente el correo instalando s-nail, un Agente de usuario de correo (MUA), también conocido como cliente de correo electrónico

      Tenga en cuenta que el objetivo de este tutorial es ayudarlo a tener en funcionamiento Postfix rápidamente con alguna funcionalidad de correo electrónico básica. Al final de esta guía no tendrá un servidor de correo electrónico con funcionalidad completa, pero tendrá algunos de los componentes básicos de dicha configuración para ayudarlo a comenzar.

      Requisitos previos

      Para seguir esta guía, necesitará lo siguiente:

      Tenga en cuenta que este tutorial asume que está configurando un host que tiene el FQDN de mail.example.com. Siempre que sea necesario, asegúrese de cambiar example.com o mail.example.com para que refleje su propio FQDN.

      Paso 1: Instalar Postfix

      Postfix se incluye en los repositorios predeterminados de Ubuntu, para que pueda instalarlo con APT.

      Para comenzar, actualice su caché de paquetes apt local:

      Luego instale el paquete postfix con el siguiente comando. Observe que aquí pasamos la variable ambiental DEBIAN_PRIORITY=low en el comando de instalación. Esto hará que el proceso de instalación le solicite que configure algunas opciones adicionales:

      • sudo DEBIAN_PRIORITY=low apt install postfix

      Este proceso de instalación abrirá una serie de solicitudes interactivas. A efectos de este tutorial, utilice la siguiente información para completar las solicitudes:

      • ¿Tipo general de configuración de correo?: para esto, elegiremos Internet Site debido a que coincide con las necesidades de nuestra infraestructura.
      • Nombre del sistema de correo: este es el dominio básico usado para construir una dirección de correo válida cuando solo se proporciona la parte de la cuenta de la dirección. Por ejemplo, digamos que el hostname de su servidor es mail.example.com. Probablemente quiera establecer el nombre de correo del sistema a example.com, para que, dado el nombre de usuario user1, Postfix usará la dirección user1@example.com​​.
      • Destinatario de correo root y postmaster: esta es la cuenta de Linux a la que se reenviará correo enviado a root@ y postmaster@. Utilice su cuenta principal para esto. En este ejemplo, sammy.
      • Otros destinos para los que se aceptará correo: esto define los destinos de correo que aceptará esta instancia de Postfix. Si necesita añadir cualquier otro dominio que este servidor sea responsable de recibir, añádalos aquí. De lo contrario, el predeterminado será suficiente.
      • ¿Forzar actualizaciones sincronizadas en la cola de correo?: ya que probablemente utilice un sistema de archivos con registro diario, seleccione No aquí.
      • Redes locales: esta es una lista de las redes para las que se configura su servidor de correo para la transmisión de mensajes. La predeterminada debería funcionar para la mayoría de los casos. Si decide modificarla, asegúrese de ser muy restrictivo con respecto al alcance de la red.
      • Límite de tamaño del buzón de correo: este valor puede usarse para limitar el tamaño de los mensajes. Si lo fija en 0, se deshabilitará la restricción de tamaño.
      • Carácter de extensión de dirección local: éste es el carácter que puede usarse para separar la parte regular de la dirección de una extensión (usada para crear alias dinámicos). El predeterminado. + funcionará para este tutorial.
      • Protocolos de Internet que se utilizarán: defina si restringirá la versión de IP que Postfix admite. A efectos de este tutorial, seleccione all (todas).

      Para ser explícito, estos son los ajustes usados en esta guía:

      • ¿Tipo general de configuración del correo?: sitio de Internet
      • Nombre del correo del sistema: example.com​​​ (no mail.example.com)
      • Destinatario de correo root y postmaster: el nombre de usuario de su cuenta Linux principal (sammy en nuestros ejemplos)
      • Otros destinos para los que aceptar correo: $myhostname, example.com, mail.example.com, localhost.example.com, localhost
      • ¿Forzar actualizaciones sincronizadas en la cola de correo? :No
      • Redes locales: 127.0.0.0/8 [:ffff:127.0.0.0]/104 [::1]/128.
      • Límite de tamaño del buzón de correo: 0
      • Carácter de extensión de dirección local: +
      • Protocolos de Internet que se utilizarán: Todos

      Nota: Si alguna vez necesita volver para configurar estos ajustes, puede hacerlo escribiendo lo siguiente:

      • sudo dpkg-reconfigure postfix

      Las instrucciones se completarán previamente con sus respuestas anteriores.

      Cuando finalice el proceso de instalación, estará listo para realizar algunas actualizaciones a su configuración de Postfix.

      Paso 2: Cambiar la configuración de Postfix

      Ahora puede realizar ciertos ajustes que el proceso de instalación del paquete no le solicitó. Muchos de los ajustes de configuración de Postfix se definen en el archivo /etc/postfix/main.cf. En vez de editar este archivo directamente, puede usar el comando postconf de Postfix para consultar o establecer los ajustes de configuración.

      Para comenzar, establezca la ubicación para el buzón de su usuario Ubuntu non-root. En esta guía, usaremos el formato Maildir, que separa los mensajes en archivos individuales que luego se mueven entre directorios según la acción del usuario. La opción alternativa que no está cubierta en esta guía es el formato mbox, que almacena todos los mensajes en un archivo único.

      Establezca la variable home_mailbox a Maildir/. Más tarde, creará una estructura de directorio bajo ese nombre en el directorio de inicio de su usuario. Configure home_mailbox escribiendo lo siguiente:

      • sudo postconf -e 'home_mailbox= Maildir/'

      A continuación, establezca la ubicación de la tabla virtual_alias_maps, que asigna cuentas de correo arbitrarias a las cuentas del sistema Linux. Ejecute el siguiente comando, que asigna la ubicación de la tabla a un archivo hash de la base de datos llamado /etc/postfix/virtual:

      • sudo postconf -e 'virtual_alias_maps= hash:/etc/postfix/virtual'

      Ahora que ha definido la ubicación del archivo de asignaciones virtuales en su archivo main.cf, puede crear el archivo en sí mismo y comenzar a asignar cuentas de correo a cuentas de usuario en su sistema Linux. Cree el archivo con su editor de texto preferido; en este ejemplo, usaremos nano:

      • sudo nano /etc/postfix/virtual

      Liste cualquier dirección para la que desee aceptar correo, seguido de un espacio en blanco y el usuario Linux al que desea que se le entregue el mensaje.

      Por ejemplo, si desea aceptar correo electrónico en contact@example.com y admin@example.comy quiere que esos correos electrónicos se entreguen al usuario de Linux sammy, podría configurar su archivo de la siguiente forma:

      /etc/postfix/virtual

      contact@example.com sammy
      admin@example.com sammy
      

      Después de asignar todas las direcciones a las cuentas del servidor correspondientes, guarde y cierre el archivo. Si utiliza nano, podrá hacer esto pulsando CTRL+X, Y y, luego, ENTER.

      Aplique la asignación escribiendo:

      • sudo postmap /etc/postfix/virtual

      Reinicie el proceso Postfix para asegurarse de que todos sus cambios se hayan aplicado:

      • sudo systemctl restart postfix

      Asumiendo que siguió la guía de requisitos previos para la configuración inicial del servidor, habrá configurado un firewall con UFW. Este firewall bloqueará las conexiones externas a los servicios en su servidor por defecto a menos que esas conexiones se permitan explícitamente, de forma que tendrá que añadir una regla de firewall para permitir una excepción para Postfix.

      Puede permitir conexiones al servicio escribiendo lo siguiente:

      Con esto, Postfix está configurado y listo para aceptar conexiones externas. Sin embargo, aún no está listo para probar con un cliente de correo. Antes de poder instalar un cliente y usarlo para interactuar con el correo que se entrega a su servidor, deberá realizar algunos cambios a la configuración de su servidor de Ubuntu.

      Paso 3: Instalar el cliente de correo e iniciar la estructura de Maildir

      Para interactuar con el correo que se entrega, este paso explicará el proceso de instalar el paquete s-nail. Esta es una variante rica en funciones del cliente xmail de BSD que puede gestionar el formato Maildir correctamente.

      Antes de instalar el cliente, sin embargo, sería prudente garantizar que su variable de entorno MAIL está configurada correctamente. s-nail buscará esta variable para determinar dónde encontrar el correo para su usaurio.

      Para garantizar que la variable MAIL está configurada independientemente de cómo accede a su cuenta (ya sea a través de ssh, su, su– o sudo, por ejemplo), deberá establecer la variable en el archivo /etc/bash.bashrc y añadirlo a un archivo en /etc/profile.d para asegurar que está configurado para todos los usuarios por defecto.

      Para agregar la variable a estos archivos, escriba lo siguiente:

      • echo 'export MAIL=~/Maildir' | sudo tee -a /etc/bash.bashrc | sudo tee -a /etc/profile.d/mail.sh

      Para leer la variable en su sesión actual, recurra al archivo /etc/profile.d/mail.sh:

      • source /etc/profile.d/mail.sh

      Con eso completado, instale el cliente de correo s-nail con APT:

      Antes de ejecutar el cliente, hay algunos ajustes que deberá realizar. Abra el archivo /etc/s-nail.rc en su editor:

      Al final del archivo, añada las siguientes opciones:

      /etc/s-nail.rc

      . . .
      set emptystart
      set folder=Maildir
      set record=+sent
      

      Estas líneas hacen lo siguiente:

      • set emptystart: permite al cliente abrir incluso con una bandeja de entrada vacía
      • set folder=Maildir: establece el directorio Maildir a la variable interna folder
      • set record=+sent crea un archivo de mbox sent para almacenar el correo enviado en el directorio que se establezca como la variable folder, en este caso Maildir

      Guarde y cierre el archivo cuando haya terminado. Ahora está listo para iniciar la estructura Maildir de su sistema.

      Una forma rápida de crear la estructura Maildir en su directorio de inicio es enviarse a usted mismo un correo con el comando s-nail. Debido a que el archivo sent solo estará disponible una vez que se cree Maildir, deberíamos deshabilitar la escritura para este correo electrónico inicial. Haga esto pasando la opción -Snorecord.

      Envíe el correo electrónico dirigiendo una cadena al comando s-nail. Ajuste el comando para marcar su usuario Linux como el destinatario:

      • echo 'init' | s-nail -s 'init' -Snorecord sammy

      Nota: Es posible que reciba la siguiente respuesta:

      Output

      Can't canonicalize "/home/sammy/Maildir"

      Esto es normal y puede aparecer únicamente cuando se envíe este primer mensaje.

      Puede verificar para asegurar que el directorio se creó buscando su directorio ~/Maildir:

      Verá que la estructura del directorio se ha creado y que hay un nuevo archivo de mensaje en el directorio ~/Maildir/new:

      Output

      /home/sammy/Maildir/: cur new tmp /home/sammy/Maildir/cur: /home/sammy/Maildir/new: 1463177269.Vfd01I40e4dM691221.mail.example.com /home/sammy/Maildir/tmp:

      Ahora que se ha creado la estructura del directorio, está listo para probar el cliente s-nail visualizando el mensaje init que envió y enviando un mensaje a una dirección de correo externa.

      Paso 5: Probar el cliente

      Para abrir el cliente, ejecute el comando s-nail:

      En su consola, verá una bandeja de entrada rudimentaria con el mensaje init esperando:

      Output

      s-nail version v14.9.15. Type `?' for help "/home/sammy/Maildir": 1 message 1 new >N 1 sammy@example.com 2020-05-19 15:40 14/392 init

      Pulse ENTER para mostrar el mensaje:

      Output

      [-- Message 1 -- 14 lines, 369 bytes --]: From sammy@example.com Tue May 19 15:40:48 2020 Date: Tue, 19 May 2020 15:40:48 +0000 To: sammy@example.com Subject: init Message-Id: <20160513220749.A278F228D9@mail.example.com> From: sammy@example.com init

      Puede volver a su lista de mensajes escribiendo h y pulsando ENTER:

      Output

      >R 1 sammy@example.com 2020-05-19 15:40 14/392 init

      Observe que el mensaje tiene un estado de R, lo que indica que ha sido leído.

      Ya que este mensaje no es muy útil, podemos borrarlo escribiendo d y pulsando ENTER:

      Para volver al terminal, escriba q y luego pulse ENTER:

      Como prueba final, compruebe si s-nail puede enviar correctamente mensajes de correo. Para hacer esto, puede canalizar los contenidos de un archivo de texto al proceso s-nail, como hizo con el mensaje init que envió en el paso anterior.

      Comience escribiendo un mensaje de prueba en un editor de texto:

      Dentro, introduzca el texto que desee enviar:

      ~/test_message

      Hello,
      
      This is a test.  Please confirm receipt!
      

      Guarde y cierre el archivo después de escribir su mensaje.

      A continuación, utilice el comando cat para canalizar el mensaje al proceso s-nail. Puede hacerlo con el siguiente ejemplo, que utiliza estas opciones:

      • -s: esto define el asunto del mensaje de correo electrónico
      • -r: cambio opcional en el campo “De” del correo electrónico. Por defecto, el usuario Linux con el que inició sesión se utilizará para completar este campo. La opción -r le permite anular esto con una dirección válida, como una de las definidas en el archivo /etc/postfix/virtual. Para ilustrar esto, el siguiente comando utiliza contact@example.com

      Además, asegúrese de cambiar user@email.com por una dirección de correo válida a la que tenga acceso:

      • cat ~/test_message | s-nail -s 'Test email subject line' -r contact@example.com user@email.com

      A continuación, navegue al buzón de entrada de la dirección de correo a la que envió el mensaje. Verá su mensaje esperando ahí casi de inmediato.

      Nota: Si el mensaje no está en su bandeja de entrada, es posible que haya sido enviado a su carpeta de spam.

      Puede ver sus mensajes enviados en su cliente s-nail. Inicie el cliente interactivo de nuevo:

      Desde el cliente de correo, vea sus mensajes enviados escribiendo:

      Verá un resultado como este:

      Output

      +[/home/sammy/Maildir/]sent: 1 message 1 new ▸N 1 contact@example.com 2020-05-19 15:47 12/297 Test email subject line

      Puede administrar el correo enviado usando los mismos comandos que emplee para el correo entrante.

      Conclusión

      Con esto, debería tener Postfix configurado en su servidor de Ubuntu 20.04. Administrar servidores de correo puede ser una tarea difícil para los administradores de sistemas novatos, pero con esta configuración, debería tener la suficiente funcionalidad MTA para comenzar.



      Source link

      Como instalar e utilizar o Docker Compose no Ubuntu 20.04


      Introdução

      O Docker simplifica o fluxo de gerenciamento de processos de aplicações em contêineres. Embora os contêineres sejam semelhantes às máquinas virtuais em certos aspectos, eles são mais leves e fáceis de usar. Isso permite que os desenvolvedores dividam um ambiente de aplicação em vários serviços isolados.

      Para aplicações que dependem de vários serviços, orquestrar todos os contêineres para iniciar, comunicar e fechar juntos pode tornar-se algo rapidamente incontrolável. O Docker Compose é uma ferramenta que lhe permite executar ambientes de aplicações com vários contêineres com base nas definições contidas em um arquivo YAML. Ele usa as definições de serviço para compilar ambientes totalmente personalizados com contêineres múltiplos que podem compartilhar redes e volumes de dados.

      Neste guia, vamos demonstrar como instalar o Docker Compose em um servidor Ubuntu 20.04 e como começar a usar esta ferramenta.

      Pré-requisitos

      Para seguir este artigo, você irá precisar do seguinte:

      • Acesso a uma máquina local com Ubuntu 20.04, ou um servidor de desenvolvimento como um usuário não-root com privilégios sudo. Se estiver usando um servidor remoto, é recomendável ter um firewall ativo instalado. Para configurar tudo isso, consulte nosso tutorial Initial Server Setup Guide for Ubuntu 20.04.
      • O Docker instalado em seu servidor ou máquina local, seguindo os Passos 1 e 2 de How To Install and Use Docker on Ubuntu 20.04.

      Passo 1 — Instalando o Docker Compose

      Para garantir que vamos obter a versão estável mais atualizada do Docker Compose, faremos o download deste software a partir do seu repositório oficial do Github.

      Primeiro, confirme a versão mais recente disponível em sua página de releases. No momento da redação deste artigo, a versão estável mais atual é a 1.26.0.

      O comando a seguir irá baixar a release 1.26.0 e salvar o arquivo executável em /usr/local/bin/docker-compose, que tornará este software globalmente acessível como docker-compose:

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

      Em seguida, defina as permissões corretas para que o comando docker-compose seja executável:

      • sudo chmod +x /usr/local/bin/docker-compose

      Para verificar se a instalação foi bem-sucedida, execute:

      Você verá um resultado parecido com este:

      Output

      docker-compose version 1.26.0, build 8a1c60f6

      O Docker Compose agora está instalado com sucesso em seu sistema. Na próxima seção, vamos ver como configurar um arquivo docker-compose.yml e obter um ambiente conteinerizado funcionando com esta ferramenta.

      Passo 2 — Configurando um arquivo docker-compose.yml

      Para demonstrar como configurar um arquivo docker-compose.yml e trabalhar com o Docker Compose, vamos criar um ambiente de servidor Web usando a imagem Nginx oficial do Docker Hub, o registro público do Docker. Este ambiente conteinerizado fornecerá um único arquivo HTML estático.

      Comece criando um novo diretório em sua pasta home e então movendo-se para ele:

      • mkdir ~/compose-demo
      • cd ~/compose-demo

      Neste diretório, configure uma pasta da aplicação para funcionar como a raiz de documentos para seu ambiente Nginx:

      Usando seu editor de texto preferido, crie um novo arquivo index.html dentro da pasta app:

      Coloque o seguinte conteúdo neste arquivo:

      ~/compose-demo/app/index.html

      <!doctype html>
      <html lang="en">
      <head>
          <meta charset="utf-8">
          <title>Docker Compose Demo</title>
          <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
      </head>
      <body>
      
          <h1>This is a Docker Compose Demo Page.</h1>
          <p>This content is being served by an Nginx container.</p>
      
      </body>
      </html>
      

      Salve e feche o arquivo quando terminar. Caso esteja usando o nano, faça isso digitando CTRL+X e, depois, Y e ENTER para confirmar.

      Em seguida, crie o arquivo docker-compose.yml:

      Insira o seguinte conteúdo em seu arquivo docker-compose.yml:

      docker-compose.yml

      version: '3.7'
      services:
        web:
          image: nginx:alpine
          ports:
            - "8000:80"
          volumes:
            - ./app:/usr/share/nginx/html
      

      O arquivo docker-compose.yml normalmente começa com a definição de version. Isso dirá ao Docker Compose qual versão de configuração estamos usando.

      Então temos o bloco services, onde configuramos os serviços que fazem parte deste ambiente. No nosso caso, temos um único serviço chamado web. Este serviço usa a imagem nginx:alpine e configura um redirecionamento de porta com a diretiva ports. Todas as requisições na porta 8000 da máquina host (o sistema a partir do qual você está executando o Docker Compose) serão redirecionadas para o contêiner web na porta 80, onde o Nginx estará em execução.

      A diretiva volumes irá criar um volume compartilhado entre a máquina host e o contêiner. Isso irá compartilhar a pasta local app com o contêiner, e o volume estará localizado em /usr/share/nginx/html dentro do contêiner. Assim, ele substituirá a raiz dos documentos padrão para o Nginx.

      Salve e feche o arquivo.

      Criamos uma página demo e um arquivo docker-compose.yml para criar um ambiente conteinerizado de servidor Web que irá apresentá-la. No próximo passo, vamos ativar este ambiente com o Docker Compose.

      Passo 3 — Executando o Docker Compose

      Com o arquivo docker-compose.yml no lugar, agora podemos executar o Docker Compose para ativar o nosso ambiente. O comando a seguir irá baixar as imagens Docker necessárias, criar um contêiner para o serviço web, e executar o ambiente conteinerizado em segundo plano.

      O Docker Compose procurará primeiro pela imagem definida no sistema local, e se ele não puder localizar a imagem ele irá baixar a imagem do Docker Hub. Você verá um resultado como esse:

      Output

      Creating network "compose-demo_default" with the default driver Pulling web (nginx:alpine)... alpine: Pulling from library/nginx cbdbe7a5bc2a: Pull complete 10c113fb0c77: Pull complete 9ba64393807b: Pull complete c829a9c40ab2: Pull complete 61d685417b2f: Pull complete Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502 Status: Downloaded newer image for nginx:alpine Creating compose-demo_web_1 ... done

      Seu ambiente agora está executando em segundo plano. Para verificar se o contêiner está ativo, você pode executar:

      Este comando irá lhe mostrar informações sobre os contêineres em execução e seus estados, bem como quaisquer redirecionamentos de porta atualmente em vigor:

      Output

      Name Command State Ports ---------------------------------------------------------------------------------- compose-demo_web_1 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Agora você pode acessar a aplicação de demonstração apontando seu navegador para localhost:8000 se você a estiver executando em sua máquina local, ou your_server_domain_or_IP:8000 no caso de um servidor remoto.

      Você verá uma página como esta:

      Docker Compose Demo Page

      Porque o volume compartilhado que você configurou dentro do arquivo docker-compose.yml mantém seus arquivos da pasta app em sincronização com a raiz de documentos do contêiner. Se você fizer quaisquer alterações no arquivo index.html, elas serão selecionadas automaticamente pelo contêiner e refletidas no navegador quando você recarregar a página.

      No próximo passo, você verá como gerenciar seu ambiente conteinerizado com comandos Docker Compose .

      Você viu como configurar um arquivo docker-compose.yml e ativar seu ambiente com docker-compose up. Agora você verá como usar comandos Docker Compose para gerenciar e interagir com seu ambiente conteinerizado.

      Para verificar os logs produzidos pelo seu contêiner Nginx, você pode usar o comando logs:

      Você verá um resultado parecido com este:

      Output

      Attaching to compose-demo_web_1 web_1 | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration web_1 | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/ web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh web_1 | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf web_1 | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh web_1 | /docker-entrypoint.sh: Configuration complete; ready for start up web_1 | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

      Se você quiser pausar a execução do ambiente sem alterar o estado atual dos seus contêineres, você pode usar:

      Output

      Pausing compose-demo_web_1 ... done

      Para retomar a execução após emitir uma pausa:

      Output

      Unpausing compose-demo_web_1 ... done

      O comando stop terminará a execução do contêiner mas ele não irá destruir quaisquer dados associados aos seus contêineres:

      Output

      Stopping compose-demo_web_1 ... done

      Se você quiser remover os contêineres, redes e volumes associados a este ambiente conteinerizado, use o comando down:

      Output

      Removing compose-demo_web_1 ... done Removing network compose-demo_default

      Observe que isso não removerá a imagem base usada pelo Docker Compose para lançar seu ambiente (no nosso caso, nginx:alpine). Desta forma, sempre que você ativar seu ambiente novamente com um docker-compose up, o processo será muito mais rápido, uma vez que a imagem já está em seu sistema.

      Caso você queira também remover a imagem base do seu sistema, use:

      • docker image rm nginx:alpine

      Output

      Untagged: nginx:alpine Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912 Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270 Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1 Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157 Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6 Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08 Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

      Nota: por favor, consulte nosso guia How to Install and Use Docker para uma referência mais detalhada sobre os comandos Docker.

      Conclusão

      Neste guia, vimos como instalar o Docker Compose e configurar um ambiente conteinerizado baseado em uma imagem de servidor Web Nginx. Também vimos como gerenciar este ambiente usando comandos Compose.

      Para uma referência completa de todos os comandos docker-compose disponíveis, verifique a documentação oficial.



      Source link

      Cómo instalar y utilizar Composer en Ubuntu 20.04


      Introducción

      Composer es una herramienta popular de administración de dependencias para PHP, creada principalmente para facilitar la instalación y actualización de dependencias de proyectos. Comprueba los demás paquetes de los que depende un proyecto específico y los instala utilizando las versiones apropiadas según los requisitos de este. Composer también se utiliza comúnmente para iniciar nuevos proyectos en función de marcos PHP populares, como Symfony y Laravel.

      A través de este tutorial, instalará y comenzará a utilizar Composer en un sistema Ubuntu 20.04.

      Requisitos previos

      Para seguir esta guía, necesitará acceso a un servidor de Ubuntu 20.04 como un non-root sudo user y un firewall habilitado en su servidor. Para configurarlo, puede consultar nuestra Guía de configuración inicial de servidores para Ubuntu 20.04.

      Paso 1: Instalar PHP y dependencias adicionales

      Además de las dependencias que ya deben estar incluidas en su sistema de Ubuntu 20.04, como git y curl, Composer requiere php-cli para ejecutar las secuencias de comandos PHP en la línea de comandos y unzip para extraer los archivos comprimidos. Instalaremos estas dependencias ahora.

      Primero, actualice la caché del administrador de paquetes ejecutando lo siguiente:

      Luego, ejecute el siguiente comando para instalar los paquetes requeridos:

      • sudo apt install php-cli unzip

      Se le solicitará confirmar la instalación escribiendo Y y luego ENTER.

      Una vez que haya instalado lo que se estipula en los requisitos previos, podrá proceder con la instalación de Composer.

      Paso 2: Descargar e instalar Composer

      Composer ofrece una secuencia de comandos de instalación escrita en PHP. La descargaremos, comprobaremos que no esté dañada y la utilizaremos para instalar Composer.

      Asegúrese de posicionarse en su directorio de inicio y obtenga el instalador usando curl:

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      A continuación, verificaremos que el instalador descargado coincida con el hash SHA-384 para el instalador más reciente disponible en la página Composer Public Keys/Signatures. A fin de facilitar el paso de verificación, puede utilizar el siguiente comando para obtener de forma programática el hash más reciente de la página de Composer y almacenarlo en una variable de shell:

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Si desea verificar el valor obtenido, puede ejecutar lo siguiente:

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Ahora, ejecute el siguiente código PHP, como se indica en la página de descarga de Composer, para verificar que la secuencia de comandos de instalación se pueda ejecutar de forma segura:

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Verá el siguiente resultado:

      Output

      Installer verified
      

      Si aparece el mensaje Installer corrupt, tendrá que volver a descargar la secuencia de comandos de instalación y verificar nuevamente si utilizó el hash correcto. Luego, repita el proceso de verificación. Cuando cuente con un instalador verificado, podrá continuar.

      Para instalar composer de manera global, utilice el siguiente comando que lo descargará e instalará en todo el sistema como un comando llamado composer, en /usr/local/bin:

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Verá un resultado similar a este:

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Para comprobar su instalación, ejecute lo siguiente:

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Esto comprueba que Composer se instaló con éxito y está disponible en todo el sistema.

      Nota: Si prefiere tener ejecutables de Composer separados para cada proyecto que aloje en este servidor, puede instalarlos localmente para cada proyecto. Este método también es útil cuando su usuario de sistema no tiene permisos para instalar software en todo el sistema.

      Para ello, utilice el comando php composer-setup.php. Con esto, se generará un archivo composer.phar en su directorio actual que puede ejecutarse con php composer.phar.

      Ahora, veamos el uso de Composer para administrar dependencias.

      Paso 3: Usar Composer en un proyecto de PHP

      Los proyectos de PHP a menudo dependen de bibliotecas externas y la administración de estas dependencias y sus versiones puede ser complicada. Composer resuelve ese problema realizando un seguimiento de las versiones y dependencias del proyecto, al mismo tiempo que facilita el proceso de búsqueda, instalación y actualización de los paquetes que requiere el proyecto.

      Para utilizar Composer en su proyecto, necesitará un archivo composer.json. El archivo composer.json indica a Composer las dependencias que debe descargar para su proyecto y las versiones de cada paquete cuya instalación está permitida. Esto es extremadamente importante para preservar la uniformidad de su proyecto y evitar la instalación de versiones inestables que podrían causar problemas de compatibilidad con versiones anteriores.

      No necesita crear este archivo de forma manual; hay muchas probabilidades de cometer errores de sintaxis al hacerlo. Composer ofrece una opción interactiva para crear un nuevo archivo composer.json en base a la entrada del usuario, una buena opción si planea compartir su proyecto más adelante como paquete público en Packagist. Composer también genera de forma automática un archivo composer.json​​ barebones cuando ejecuta un comando composer require para incluir una dependencia a un proyecto recién creado.

      Para usar Composer en la instalación de un paquete como dependencia en un proyecto, se deben seguir estos pasos:

      • Identifique el tipo de biblioteca que requiere la aplicación.
      • Busque una biblioteca de código abierto adecuada  en Packagist.org, el repositorio oficial de paquetes de Composer.
      • Elija el paquete que desee usar.
      • Ejecute composer require para incluir la dependencia en el archivo composer.json e instale el paquete.

      Probemos esto con una aplicación de demostración.

      El objetivo de esta aplicación es transformar una oración en una cadena compatible con una URL; un slug. Esto se utiliza comúnmente para convertir los títulos de páginas en rutas URL (como la parte final de la URL de este tutorial).

      Comencemos creando un directorio para nuestro proyecto. Lo llamaremos slugify:

      • cd ~
      • mkdir slugify
      • cd slugify

      Aunque no sea obligatorio, ahora podrá ejecutar un comando composer init a fin de crear un archivo composer.json detallado para su proyecto. Ya que que el único objetivo de nuestro proyecto es demostrar la forma de instalar dependencias con Composer, utilizaremos un archivo composer.json más sencillo que se generará automáticamente cuando necesitemos nuestro primer paquete.

      Ahora será el momento de buscar en Packagist.org un paquete que puede servirnos para generar slugs. Si busca el término “slug” en Packagist, obtendrá un resultado similar a este:

      Resultados de búsqueda en Packagist para el término

      Observará dos números en el lado derecho de cada paquete de la lista. El número de la parte superior representa la cantidad de veces que se instaló el paquete a través de Composer y el de la parte inferior la cantidad de veces que se destacó un paquete en GitHub. En general, los paquetes con más instalaciones y más estrellas suelen ser más estables, ya que muchas personas los utilizan. También es importante revisar la descripción del paquete para asegurarse de que se adecue a lo que usted requiere.

      Necesitamos un convertidor de cadena a slug. Conforme a los resultados de la búsqueda, el paquete cocur/slugify, que aparece como el primer resultado de esa página, parece ser una buena opción al ofrecer una cantidad razonable de instalaciones y estrellas.

      Los paquetes en Packagist tienen un nombre de proveedor y un nombre de paquete. Cada paquete tiene un identificador único (un espacio de nombres) en el mismo formato que GitHub utiliza para sus repositorios: vendor/package​​​. La biblioteca que deseamos instalar utiliza el espacio de nombres cocur/slugify. Necesita el espacio de nombres del paquete para solicitarlo en su proyecto.

      Ahora que sabe exactamente qué paquete desea instalar, puede ejecutar composer require para incluirlo como una dependencia y generar también el archivo composer.json para su proyecto: Algo que es importante destacar al requerir paquetes es que Composer realiza un seguimiento tanto de las dependencias a nivel de aplicación como de las dependencias a nivel de sistema. Las dependencias a nivel de sistema son importantes para indicar en qué módulos PHP se basa un paquete. En el caso del paquete cocur/slugify, requiere un módulo PHP que aún no hemos instalado.

      Cuando un paquete requerido se basa en una biblioteca del sistema que no esté instalada actualmente en su servidor, recibirá un mensaje de error indicando el requisito que falta:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Para resolver el problema de dependencia del sistema, podemos buscar el paquete que falta utilizando apt search​​​:

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Después de ubicar el nombre del paquete correcto, puede utilizar apt una vez más para instalar la dependencia del sistema:

      • sudo apt install php-mbstring

      Una vez que la instalación haya finalizado, podrá ejecutar el comando composer require de nuevo:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Como se observa en el resultado, Composer automáticamente decidió la versión del paquete que utilizará. Si revisa el directorio de su proyecto, este contendrá dos nuevos archivos, composer.json y composer.lock, y un directorio vendor:

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      El archivo composer.lock se utiliza para almacenar información sobre las versiones de cada paquete que están instaladas y garantizar que se utilicen las mismas versiones si otra persona clona su proyecto e instala sus dependencias. En el directorio vendor se ubican las dependencias del proyecto. La carpeta vendor no debe comprometerse con el control de versión; solo debe incluir los archivos composer.json y composer.lock.

      Al instalar un proyecto que ya contenga un archivo composer.json, ejecute composer install para descargar las dependencias del proyecto.

      Veamos rápidamente las restricciones de versiones. Si verifica los contenidos de su archivo composer.json, verá algo parecido a lo siguiente:

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Posiblemente observe el carácter especial ^ antes del número de versión en composer.json. A fin de proporcionar flexibilidad y a su vez mantener la estabilidad de su proyecto, Composer admite diferentes restricciones y formatos para definir la versión requerida del paquete. El operador del símbolo de intercalación (^) utilizado por el archivo de generación automática composer.json es el operador recomendado para una máxima interoperabilidad, seguido del control de versión semántico. En este caso, define la versión 4.0 como la versión de compatibilidad mínima y permite actualizaciones a cualquier versión futura inferior a la 5.0.

      En general, no tendrá que alterar las restricciones de versiones de su archivo composer.json. Sin embargo, en algunas situaciones posiblemente deba editar las restricciones manualmente; por ejemplo, cuando se lance una nueva versión importante de su biblioteca requerida y desee actualizarla, o cuando la biblioteca que desee utilizar no siga el control de versión semántico.

      Aquí se muestran algunos ejemplos para que comprenda mejor el funcionamiento de las restricciones de versiones de Composer:

      Restricción Significado Versiones de ejemplos permitidas
      ^1.0 >= 1.0 < 2.0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1.0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.0, 1.0.4, 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1.0 < 2.0 1.0.0, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Para acceder a una perspectiva más detallada de las restricciones de versiones de Composer, consulte la documentación oficial.

      A continuación, veamos la forma de cargar las dependencias automáticamente con Composer.

      Paso 4: Incluir la secuencia de comandos de carga automática

      Dado que PHP por sí mismo no carga automáticamente las clases, Composer proporciona una secuencia de comandos de carga automática que puede incluir en su proyecto para que la carga automática funcione en su proyecto. Composer genera este archivo de manera automática al añadir su primera dependencia.

      Lo único que debe hacer es incluir el archivo vendor/autoload.php en sus secuencias de comandos de PHP antes de cualquier instancia de clase.

      Probemos esto en nuestra aplicación de demostración. Abra un archivo nuevo llamado test.php en su editor de texto:

      Añada el siguiente código que agrega el archivo vendor/autoload.php, carga la dependencia cocur/slugify y la utiliza para crear un slug:

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Guarde el archivo y cierre el editor.

      Ahora ejecute la secuencia de comandos:

      El resultado de esto es hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

      Las dependencias necesitan actualizaciones cuando se lanzan nuevas versiones. Veamos la forma de manejar eso.

      Paso 5: Actualizar dependencias del proyecto

      Cuando desee actualizar las dependencias de proyecto a versiones más recientes, ejecute el comando update:

      Con esto, se buscarán versiones más recientes de las bibliotecas que necesitó en su proyecto. Si se encuentra una versión más reciente y es compatible con la restricción de versión definida en el archivo composer.json, Composer sustituirá la versión anterior instalada. El archivo composer.lock se actualizará para reflejar estos cambios.

      También puede actualizar una o más bibliotecas determinadas especificándolas de la siguiente manera:

      • composer update vendor/package vendor2/package2

      Después de actualizar sus dependencias, asegúrese de verificar sus archivos composer.json y composer.lock en su sistema de control de versiones para que otros también puedan instalar estas versiones más recientes.

      Conclusión

      Composer es una herramienta poderosa que puede facilitar mucho el trabajo de gestionar dependencias en proyectos PHP. Ofrece una manera confiable de descubrir, instalar y actualizar los paquetes PHP de los que depende un proyecto. En esta guía, vimos cómo instalar Composer, incluir nuevas dependencias en un proyecto y actualizar estas dependencias una vez que haya nuevas versiones disponibles.



      Source link