{"meta":{"title":"Comunicar-se com os contêineres de serviço do Docker","intro":"Saiba como usar contêineres de serviço do Docker para conectar bancos de dados, serviços web, memória cache e outras ferramentas ao seu fluxo de trabalho.","product":"GitHub Actions","breadcrumbs":[{"href":"/pt/actions","title":"GitHub Actions"},{"href":"/pt/actions/tutorials","title":"Tutoriais"},{"href":"/pt/actions/tutorials/use-containerized-services","title":"Usar serviços em contêineres"},{"href":"/pt/actions/tutorials/use-containerized-services/use-docker-service-containers","title":"Usar contêineres de serviço do Docker"}],"documentType":"article"},"body":"# Comunicar-se com os contêineres de serviço do Docker\n\nSaiba como usar contêineres de serviço do Docker para conectar bancos de dados, serviços web, memória cache e outras ferramentas ao seu fluxo de trabalho.\n\n## Comunicar-se com os contêineres de serviço do Docker\n\nOs contêineres de serviço são contêineres Docker que oferecem uma maneira simples e portátil de hospedar serviços que você pode precisar testar ou executar sua aplicação em um fluxo de trabalho. Por exemplo, o seu fluxo de trabalho pode precisar executar testes de integração que necessitem de acesso a um banco de dados e a uma memória cache.\n\nVocê pode configurar os contêineres de serviço para cada trabalho em um fluxo de trabalho.\nGitHub cria um novo contêiner do Docker para cada serviço configurado no fluxo de trabalho e destrói o contêiner de serviço quando o trabalho é concluído. As etapas em um trabalho podem comunicar-se com todos os contêineres de serviço que fazem parte do mesmo trabalho. No entanto, não é possível criar nem usar contêineres de serviço em uma ação composta.\n\n> \\[!NOTE]\n> Se os fluxos de trabalho usarem ações de contêiner do Docker, contêineres de trabalho ou contêineres de serviço, você precisará usar um executor do Linux:\n>\n> * Se você estiver usando executores hospedados em GitHub, você deverá usar um executor do Ubuntu.\n> * Se você estiver usando executores auto-hospedados, você deve usar uma máquina Linux, pois seu executor e o Docker precisam ser instalados.\n\nVocê pode configurar trabalhos em um fluxo de trabalho para ser executados diretamente em uma máquina executora ou em um contêiner Docker. A comunicação entre o trabalho e seus contêineres de serviço é diferente, dependendo se um trabalho é executado diretamente na máquina executora ou em um contêiner.\n\n### Executar trabalhos em um contêiner\n\nQuando você executa trabalhos em um contêiner, GitHub conecta contêineres de serviço ao trabalho usando redes de ponte definidas pelo usuário do Docker. Para obter mais informações, confira [Driver de rede de ponte](https://docs.docker.com/engine/network/drivers/bridge/) na documentação do Docker.\n\nExecutar o trabalho e os serviços em um contêiner simplifica o acesso à rede. Você pode acessar um contêiner de serviço usando a etiqueta que você configurar no fluxo de trabalho. O nome de host do contêiner do serviço é mapeado automaticamente de acordo com o nome da etiqueta. Por exemplo, se você criar um contêiner de serviço com o rótulo `redis`, o nome do host do contêiner de serviço será `redis`.\n\nVocê não precisa configurar nenhuma porta para os contêineres de serviço. Por padrão, todos os contêineres que fazem parte da mesma rede do Docker expõem todas as portas entre si e nenhuma porta é exposta fora da rede do Docker.\n\n### Executar trabalhos na máquina executora\n\nAo executar trabalhos diretamente na máquina do runner, você pode acessar os contêineres de serviço usando `localhost:<port>` ou `127.0.0.1:<port>`.\nGitHub configura a rede de contêiner para habilitar a comunicação do contêiner de serviço para o host do Docker.\n\nQuando um trabalho é executado diretamente em uma máquina executora, o serviço executado no contêiner do Docker não expõe suas portas ao trabalho no executor por padrão. Você deve mapear as portas do contêiner de serviço para o host do Docker. Para saber mais, confira [Comunicar-se com os contêineres de serviço do Docker](/pt/actions/using-containerized-services/about-service-containers#mapping-docker-host-and-service-container-ports).\n\n## Criar contêineres de serviço\n\nUse a palavra-chave `services` para criar contêineres de serviço que fazem parte de um trabalho no fluxo de trabalho. Para obter mais informações, confira [`jobs.<job_id>.services`](/pt/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idservices).\n\nEste exemplo cria um serviço chamado `redis` em um trabalho chamado `container-job`. O host do Docker neste exemplo é o contêiner `node:16-bullseye`.\n\n```yaml copy\nname: Redis container example\non: push\n\njobs:\n  # Label of the container job\n  container-job:\n    # Containers must run in Linux based operating systems\n    runs-on: ubuntu-latest\n    # Docker Hub image that `container-job` executes in\n    container: node:16-bullseye\n\n    # Service containers to run with `container-job`\n    services:\n      # Label used to access the service container\n      redis:\n        # Docker Hub image\n        image: redis\n```\n\n## Mapear o host do Docker e as portas do contêiner de serviço\n\nSe o seu trabalho for executado em um contêiner do Docker, você não precisará mapear as portas no host ou no contêiner de serviço. Se o seu trabalho for executado diretamente na máquina executora, você precisará mapear todas as portas do contêiner de serviço necessárias com as portas na máquina executora do host.\n\nVocê pode mapear portas de contêineres de serviço para o host do Docker usando a palavra-chave `ports`. Para obter mais informações, confira [`jobs.<job_id>.services`](/pt/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idservices).\n\n| Valor de `ports` | Descrição                                                                        |\n| ---------------- | -------------------------------------------------------------------------------- |\n| `8080:80`        | Mapeia a porta 80 TCP no contêiner com a porta 8080 no host do Docker.           |\n| `8080:80/udp`    | Mapeia a porta 80 UDP no contêiner com a porta 8080 no host do Docker.           |\n| `8080/udp`       | Mapeia uma porta aleatória no host do Docker para a porta UDP 8080 no contêiner. |\n\nQuando você mapeia portas usando a `ports` palavra-chave, GitHub usa o `--publish` comando para publicar as portas do contêiner no host do Docker. Para obter mais informações, confira [Rede de contêineres do Docker](https://docs.docker.com/config/containers/container-networking/) na documentação do Docker.\n\nAo especificar a porta do contêiner mas não a porta do Docker, a porta do contêiner será atribuída aleatoriamente a uma porta livre.\nGitHub define a porta de contêiner atribuída no contexto do contêiner de serviço. Por exemplo, para um contêiner de serviço `redis`, se você tiver configurado a porta de host do Docker 5432, poderá acessar a porta de contêiner correspondente usando o contexto `job.services.redis.ports[5432]`. Para saber mais, confira [Referência de contextos](/pt/actions/learn-github-actions/contexts#job-context).\n\n### Exemplo de mapeamento de portas Redis\n\nEste exemplo mapeia a porta `redis` do contêiner de serviço 6379 para a porta 6379 do host do Docker.\n\n```yaml copy\nname: Redis Service Example\non: push\n\njobs:\n  # Label of the container job\n  runner-job:\n    # You must use a Linux environment when using service containers or container jobs\n    runs-on: ubuntu-latest\n\n    # Service containers to run with `runner-job`\n    services:\n      # Label used to access the service container\n      redis:\n        # Docker Hub image\n        image: redis\n        #\n        ports:\n          # Opens tcp port 6379 on the host and service container\n          - 6379:6379\n```\n\n## Autenticando com registros de imagem\n\nVocê poderá especificar credenciais para os contêineres de serviço se precisar fazer autenticação com um registro de imagem. Isso permite a você usar imagens de registros privados ou [aumentar o limite de taxa do DockerHub](https://www.docker.com/increase-rate-limits/).\n\nAqui está um exemplo de autenticação com o Docker Hub e GitHubContainer registry:\n\n```yaml copy\njobs:\n  build:\n    services:\n      redis:\n        # Docker Hub image\n        image: redis\n        ports:\n          - 6379:6379\n        credentials:\n          username: ${{ secrets.dockerhub_username }}\n          password: ${{ secrets.dockerhub_password }}\n      db:\n        # Private registry image\n        image: ghcr.io/octocat/testdb:latest\n        credentials:\n          username: ${{ github.repository_owner }}\n          password: ${{ secrets.ghcr_password }}\n```\n\n## Personalizando os pontos de entrada e os comandos do contêiner de serviço\n\nPor padrão, os contêineres de serviço são executados com o ponto de entrada e o comando definidos na imagem do Docker. Você pode substituí-los usando as teclas `entrypoint` e `command`. Isso é útil quando você precisa passar sinalizadores para um serviço (como um banco de dados) ou trocar totalmente o ponto de entrada da imagem, sem criar uma imagem de wrapper personalizada.\n\nA `command` chave substitui o comando padrão da imagem (`CMD`). A maioria dos cenários só precisa `command` — a imagem já tem o ponto de entrada certo, você só precisa passar sinalizadores:\n\n```yaml copy\nservices:\n  mysql:\n    image: mysql:8\n    command: --sql_mode=STRICT_TRANS_TABLES --max_allowed_packet=512M\n    env:\n      MYSQL_ROOT_PASSWORD: test\n    ports:\n      - 3306:3306\n```\n\nA `entrypoint` chave substitui o `ENTRYPOINT` da imagem. Você pode combiná-lo com `command` para passar argumentos ao ponto de entrada personalizado.\n\n```yaml copy\nservices:\n  etcd:\n    image: quay.io/coreos/etcd:v3.5.17\n    entrypoint: etcd\n    command: >-\n      --listen-client-urls http://0.0.0.0:2379\n      --advertise-client-urls http://0.0.0.0:2379\n    ports:\n      - 2379:2379\n```\n\nA nomenclatura e o comportamento correspondem ao Docker Compose. Para obter mais informações, consulte [`jobs.<job_id>.services.<service_id>.command`](/pt/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idservicesservice_idcommand) e [`jobs.<job_id>.services.<service_id>.entrypoint`](/pt/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idservicesservice_identrypoint).\n\n## Leitura adicional\n\n* [Criando contêineres de serviço Redis](/pt/actions/using-containerized-services/creating-redis-service-containers)\n* [Criar contêineres de serviço PostgreSQL](/pt/actions/using-containerized-services/creating-postgresql-service-containers)"}