Configurar executores auto-hospedados para uso corporativo

9 minutos

Na unidade anterior, você explorou como escolher e gerenciar executores hospedados e auto-hospedados no GitHub em um alto nível. Nesta unidade, você aprenderá a configurar, organizar, monitorar e proteger corredores auto-hospedados para uso em escala empresarial. Isso inclui:

Configurando os executores com proxies e rótulos personalizados
Gerenciando grupos de executores
Monitorando a saúde e o desempenho do corredor
Configurando o acesso seguro usando rótulos e listas de permissões de IP

Configurar executores auto-hospedados para uso corporativo

Os executores auto-hospedados no GitHub Actions fornecem maior flexibilidade e controle para empresas que exigem ambientes personalizados, acesso à rede e proteção de segurança. Este guia aborda as melhores práticas para configurar executores auto-hospedados, incluindo considerações de proxies, rótulos e rede.

1. Configurando um executor auto-hospedado

Etapa 1: Criar e registrar um executor auto-hospedado

Navegue até o GitHub Enterprise → Configurações → Actions → Runners.
Clique em Novo Executor e selecione o sistema operacional desejado (Linux, Windows ou macOS).
Siga os comandos fornecidos para instalar e configurar o executor em seu computador.

Etapa 2: Instalar e iniciar o executor

Execute os seguintes comandos com base no sistema operacional:

Linux/macOS

./config.sh --url https://github.com/<org-name> --token <generated-token>
./run.sh

Windows (PowerShell)

.\config.cmd --url https://github.com/<org-name> --token <generated-token>
.\run.cmd

2. Configurando proxies para executores auto-hospedados

As empresas geralmente operam atrás de firewalls corporativos e proxies que restringem o acesso à Internet. Para permitir que os executores auto-hospedados se comuniquem com o GitHub, defina as configurações de proxy da seguinte maneira:

Linux/macOS: configurar o proxy

Edite o arquivo de ambiente para definir as configurações de proxy:

export http_proxy=http://proxy.company.com:8080
export https_proxy=http://proxy.company.com:8080
export no_proxy=localhost,127.0.0.1

Aplique as configurações:

source ~/.bashrc

Windows: Configurar proxy

Use os seguintes comandos do PowerShell:

[System.Environment]::SetEnvironmentVariable("HTTP_PROXY", "http://proxy.company.com:8080", "Machine")
[System.Environment]::SetEnvironmentVariable("HTTPS_PROXY", "http://proxy.company.com:8080", "Machine")

3. Usando Rótulos para gerenciamento de executor

Os rótulos ajudam a organizar e rotear trabalhos para executores auto-hospedados específicos com base nos requisitos de SO, hardware ou projeto.

Captura de tela da tela de grupos de executores com o rótulo padrão.

Atribuindo etiquetas a um corredor

Ao configurar um executor, você pode atribuir rótulos personalizados:

./config.sh --url https://github.com/<org-name> --token <generated-token> --labels "high-memory,gpu"

Direcionando um executor específico em um fluxo de trabalho

Para executar um trabalho em um executor específico com rótulos, atualize o fluxo de trabalho .yml:

jobs:
  build:
    runs-on: [self-hosted, high-memory]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

4.Considerações sobre rede

IPs do GitHub da lista de permitidos

Os executores hospedados no GitHub operam em IPs dinâmicos, mas os executores auto-hospedados precisam de regras de firewall para permitir o acesso. Recupere os intervalos de IP mais recentes do GitHub:

curl -s https://api.github.com/meta | jq .actions

Permita que esses IPs em suas configurações de firewall garantam a conectividade.

Acesso à rede privada & VPN

Para cargas de trabalho corporativas que exigem acesso a sistemas privados, configure o executor para se conectar via VPN ou uma rede interna.

5. Práticas recomendadas de segurança para corredores corporativos

Restringir os executores a fluxos de trabalho confiáveis: impedir a execução de código não confiável em executores auto-hospedados.
Usar executores efêmeros: Remova automaticamente os executores após os trabalhos para evitar ameaças persistentes.
Monitorar a atividade do executor: Registrar todas as ações do executor e auditar o acesso.
Aplicar patches de segurança do sistema operacional: atualize regularmente e proteja o computador executor.

Gerenciar executores auto-hospedados usando grupos

Os grupos de executores permitem que as organizações gerenciem o acesso, controlem a distribuição da carga de trabalho e imponham políticas de segurança para executores auto-hospedados no GitHub Actions. Este guia aborda como criar, gerenciar e mover corredores entre grupos efetivamente.

1. Noções básicas sobre grupos de corredores

Os grupos de executores ajudam a organizar e controlar executores auto-hospedados em um GitHub Enterprise ou Organização. Eles permitem:

Restringir quais repositórios podem usar executores específicos.
Controlando a disponibilidade do executor para diferentes equipes ou cargas de trabalho.
Gerenciando permissões para branches, fluxos de trabalho ou ambientes específicos.

Disponibilidade do grupo de executores

Plano do GitHub	Grupos de Runners disponíveis?
GitHub Gratuito	❌ Não disponível
GitHub Pro	❌ Não disponível
GitHub Equipe	✅ Disponível
GitHub Enterprise	✅ Disponível

2. Criando um grupo de executores

Acesse o GitHub → Organization Settings → Actions → Runners.
Clique em "Novo grupo" emSelf-Hosted Runners.
Forneça um nome para o grupo (por exemplo, "Linux-Runners", "High-Memory").
Escolha quem pode acessar o grupo (organização inteira ou repositórios específicos).
Clique em Save (Salvar).

Captura de tela da tela do formulário de criação de grupo de executores.

3. Adicionar Executores a um Grupo

Depois que o grupo for criado, você poderá adicionar participantes manualmente ou no momento da inscrição.

Opção 1: Atribuir durante o registro

Ao configurar um novo executor, especifique o grupo:

./config.sh --url https://github.com/<org-name> --token <generated-token> --runnergroup "Linux-Runners"

Opção 2: Mover um executor existente

Navegue até o GitHub → Configurações da Organização → Actions → Runners.
Localize o executor e clique em Editar.
Selecione um novo grupo de executores e salve as alterações.

4. Gerenciamento de acesso e permissões

Restringindo o acesso ao grupo de executores

Executores de nível de organização: Restringir o uso a repositórios específicos. Executores de nível de repositório: Somente fluxos de trabalho selecionados podem acessar o executor.

Exemplo: restringir o acesso a um repositório específico

Navegue até as Configurações de Grupo do Executor.
Em Acesso ao Repositório, selecione "Selecionar somente repositórios".
Adicionar os repositórios que têm permissão para usar o grupo de executores.

5. Mover executores entre grupos

Para reatribuir um executor de um grupo para outro:

Acesse o GitHub → Configurações da Organização → Actions → Runners.
Clique no nome do executor.
Selecione Alterar grupo → Escolher um novo grupo.
Clique em Salvar. Como alternativa, cancele o registro e registre novamente o runner em um grupo diferente:

./config.sh remove
./config.sh --url https://github.com/<org-name> --token <generated-token> --runnergroup "New-Group"

Crie grupos separados para diferentes tipos de sistema operacional (por exemplo, Windows, Linux e macOS).
Use rótulos para classificar ainda mais os executores (por exemplo, GPU, memória alta, ARM).
Limite o acesso do executor somente a repositórios confiáveis.
Audite e atualize regularmente grupos de executores com base nos requisitos da equipe.
Monitore o uso e o desempenho do executor para otimizar cargas de trabalho de CI/CD.

Monitorar, solucionar problemas e atualizar executores auto-hospedados**

O gerenciamento de executores auto-hospedados efetivamente requer monitoramento contínuo, solução de problemas proativa e atualizações regulares. Este guia aborda as práticas recomendadas e os métodos recomendados pelo GitHub para garantir alta disponibilidade, segurança e desempenho de executores auto-hospedados.

1. Monitoramento de executores auto-hospedados

Verificando o status do executor

Para monitorar a disponibilidade do executor:

Navegue até GitHub → Configurações da Organização → Ações → Executores.
Examine o status:
- ✅Ocioso → Pronto para fluxos de trabalho.
- 🔄Ativo → atualmente executando uma tarefa.
- ❌Offline → Runner está inoperante ou desconectado.

Usando a API do GitHub para buscar o status do executor

Você pode verificar programaticamente o status dos executores auto-hospedados:

curl -H "Authorization: token <your_github_token>" \
     -H "Accept: application/vnd.github.v3+json" \
     https://api.github.com/orgs/<org-name>/actions/runners

Exemplo de resposta:

{
  "total_count": 2,
  "runners": [
    {
      "id": 1,
      "name": "runner-1",
      "status": "online"
    },
    {
      "id": 2,
      "name": "runner-2",
      "status": "offline"
    }
  ]
}

Registro em log e métricas

Logs do Sistema: Verifique os logs no diretório _diag/ dentro da pasta de instalação do executor.
Logs de fluxo de trabalho do GitHub Actions: Navegue até Ações → Execução do Fluxo de Trabalho → Logs para ver os detalhes de execução do executor.
Monitoramento via Prometheus/Grafana: Configure os exportadores do Prometheus para acompanhar a CPU, a memória e o tempo de execução do trabalho.

2. Solução de problemas de executores auto-hospedados

Problemas e correções comuns

Questão	Causa possível	Correção
O executor mostra Offline	Problema de rede, token expirado, ou falha no runner	Reinicie o executador: `./run.sh`
Trabalho preso no estado Enfileirado	Nenhum executor disponível com rótulos necessários	Adicionar executores ou atualizar rótulos
Processo falha devido a erros de permissão	Permissões de executor incorretas	Verifique se o executor tem o acesso correto
A execução do fluxo de trabalho é lenta	Alto uso de CPU/memória	Monitorar métricas do sistema e escalonar executores

Reiniciando um executor

Se um executor estiver travado ou não estiver respondendo, reinicie-o:

./svc.sh stop
./svc.sh start

Para executores do Linux baseados em systemd:

sudo systemctl restart actions.runner.<org-name>.<runner-name>.service

Verificando os logs em busca de erros

Logs do executor:<runner_dir>/_diag/Runner_<timestamp>.logLogs do GitHub Actions: Verifique os logs de execução do fluxo de trabalho na interface do usuário do GitHub.

3. Atualização de executores auto-hospedados

Verificando se há atualizações do executor

O GitHub atualiza periodicamente os binários do executor. Para verificar se há atualizações:

./config.sh --version

Você também pode verificar as versões do runner por meio da API.

curl -H "Authorization: token <your_github_token>" \
     -H "Accept: application/vnd.github.v3+json" \
     https://api.github.com/repos/actions/runner/releases/latest

Atualizando o executor

1. Atualização manual Parar o executor

./svc.sh stop

2. Baixar o executor mais recente:

curl -o actions-runner-linux-x64.tar.gz -L \
     https://github.com/actions/runner/releases/latest/download/actions-runner-linux-x64.tar.gz

3.Extrair e reconfigurar:

tar xzf ./actions-runner-linux-x64.tar.gz
./config.sh --url https://github.com/<org-name> --token <generated-token>
./svc.sh install
./svc.sh start

Atualizações automatizadas com ações do GitHub

Para verificar e atualizar automaticamente os executores:

name: Update Runners

on:
  schedule:
    - cron: '0 3 * * 1'  # Runs every Monday at 3 AM

jobs:
  update-runners:
    runs-on: self-hosted
    steps:
      - name: Download and update runner
        run: |
          ./svc.sh stop
          curl -o actions-runner.tar.gz -L \
          https://github.com/actions/runner/releases/latest/download/actions-runner-linux-x64.tar.gz
          tar xzf actions-runner.tar.gz
          ./config.sh --url https://github.com/<org-name> --token <generated-token>
          ./svc.sh start

Comentários

Esta página foi útil?