Introdução ao Rails Console do GitLab para administração avançada

0
33


O console Rails do GitLab fornece um terminal interativo que permite manipular dados diretamente em sua instância do GitLab. Você pode usá-lo para extrair informações, solucionar problemas e executar tarefas de administração avançadas que não são compatíveis com a API do GitLab ou a interface do usuário da web.

Para acessar o console, você deve executar seu próprio servidor GitLab autogerenciado. Você precisará de privilégios de root na máquina que hospeda seu ambiente. O console fornece controle irrestrito sobre o GitLab e seus dados, portanto, apenas administradores confiáveis ​​devem poder usá-lo. As ações podem anular as medidas normais de segurança e causar a destruição de dados sem aviso prévio.

Inicie o console

O método usado para iniciar o console depende do tipo de instalação do GitLab que você está executando. As distribuições Omnibus instaladas a partir de um gerenciador de pacotes suportam o seguinte comando:

$ sudo gitlab-rails console

Use esta alternativa se você instalou manualmente o GitLab da fonte:

$ sudo -u git -H bundle exec rails console -e production

O console também está disponível para instâncias do GitLab nativas da nuvem em execução no Kubernetes. Use Kubectl para anexar ao GitLab’s toolbox Pod e inicie uma sessão de console:

$ kubectl --namespace gitlab exec -it toolbox -- /srv/gitlab/bin/rails console

As versões do GitLab anteriores a 14.2 terão um task-runner vagem em vez de toolbox. Substituto task-runner no comando mostrado acima se você estiver executando uma dessas versões.

O console do Rails pode levar vários segundos para iniciar. Ele exibirá um resumo de suas versões do Ruby, GitLab e PostgreSQL antes de levá-lo a um prompt do terminal.

$ sudo gitlab-rails console
--------------------------------------------------------------------------------
 Ruby:         ruby 2.7.5p203 (2021-11-24 revision f69aeb8314) [x86_64-linux]
 GitLab:       15.0.0 (8a186dedfc1) FOSS
 GitLab Shell: 14.3.0
 PostgreSQL:   12.10
------------------------------------------------------------[ booted in 22.48s ]
Loading production environment (Rails 6.1.4.7)
irb(main):001:0>

Você pode começar a emitir comandos Ruby quando vir o prompt aparecer.

uso básico

O console fornece acesso ao ambiente Ruby on Rails do GitLab. Os objetos Scope permitem que você obtenha, atualize e consulte dados em seu banco de dados GitLab. Um entendimento básico de Ruby e Rails irá ajudá-lo a começar.

Rails usa o padrão Active Record para fornecer métodos para mapear dados estáticos para objetos. Você pode chamar o seguinte método para recuperar um usuário pelo nome de usuário:

$ demo = User.find_by_username("demo")
# <User id:1 @demo>

Você pode ver as propriedades do objeto recuperado inspecionando seu attributes:

$ pp demo.attributes
{"id"=>1,
 "email"=>"[email protected]",
...

Para recuperar uma propriedade específica, acesse-a pelo nome:

$ demo.email
[email protected]

Você pode usar métodos Rails para obter convenientemente várias instâncias de objetos que correspondem a uma consulta:

$ admins = User.where(admin: true).where('email like ?', '%@example.com')

Isso recupera todos example.com usuários com permissões de administrador do GitLab.

Você pode alterar as propriedades de uma instância de objeto atribuindo novos valores e chamando save:

$ demo.email = "[email protected]"
$ demo.save

a save O método verificará o objeto quanto a um estado válido antes de salvá-lo no banco de dados. Você pode desabilitar explicitamente a validação em situações em que deseja forçar a aplicação de uma alteração específica:

$ demo.save!(validate: false)

Isso só deve ser usado para investigar problemas em que a API do GitLab ou a interface do usuário da Web rejeitam dados inesperadamente.

Tarefas comuns

O console do GitLab Rails tem aplicativos ilimitados, pois você pode trabalhar com qualquer aspecto da sua instância do GitLab. Aqui estão algumas operações úteis para você começar.

Descubra os métodos disponíveis em um objeto

A experiência do console pode ser assustadora para novatos, especialmente se você não estiver muito familiarizado com Rails. A documentação no console é relativamente escassa, mas você pode descobrir a funcionalidade recuperando a lista de métodos associados a cada objeto:

$ User.methods
[:before_add_for_closed_issues, :before_add_for_closed_issues=, :after_add_for_closed_issues, ...]

Você pode combinar isso com grep para filtrar rapidamente para métodos com uma raiz específica:

$ Project.methods.grep(/find/)
[:find_by_runners_token, :find_by_url, :find_by_full_path, ...]

Isso revela que você pode procurar um projeto por seu caminho com o seguinte comando:

$ Project.find_by_full_path("/user/project")

Recuperar um projeto com seus problemas e solicitações de mesclagem

Primeiro use o Project object para obter o projeto correspondendo a um atributo exclusivo, como seu ID, caminho ou URL:

$ project = Project.find_by_full_path("/user/project")

Agora você pode acessar problemas do projeto e solicitações de mesclagem por meio de suas propriedades de relacionamento:

# Get all issues
$ project.issues.all

# Get the first issue
$ project.issues.first

# Get a specific merge request by its project-level ID
$ project.merge_requests.find_by(iid: 10)

Trazer de volta o pipeline de CI

a Pipeline o objeto está aninhado dentro do CI namespace:

# Get the pipeline with ID 100
$ pipeline = Ci::Pipeline.find(100)

# Get builds (jobs) associated with the pipeline
$ jobs = pipeline.builds

Redefinir uma senha de administrador

O console pode salvá-lo se você for bloqueado de sua conta. Recupere o objeto de usuário afetado e redefina sua senha:

$ user = User.find_by_username("demo")
$ user.password = "abc123"
$ user.password_confirmation = "abc123"
$ user.save

Tornar um projeto somente leitura

O GitLab oferece suporte a projetos somente leitura que mantêm o repositório acessível, mas impedem modificações. O modo somente leitura deve ser ativado por meio do console:

$ project = Project.find_by_full_path("/user/project")
$ project.repository_read_only = true
$ project.save

Executar manualmente uma programação de pipeline

Os pipelines agendados podem ser executados imediatamente usando o console. Às vezes, isso pode ajudar a depurar problemas que não são totalmente relatados na interface do usuário e na API.

primeiro recupere o PipelineSchedule objeto:

$ schedule = Ci::PipelineSchedule.find_by(id: 10)

Em seguida, obtenha o usuário com o qual você deseja executar o pipeline:

$ user = User.find_by_username("demo")

Agora use este comando para iniciar uma execução pelo agendamento:

$ Ci::CreatePipelineService.new(schedule.project, user, ref: schedule.ref).execute!(:schedule, ignore_skip_ci: true, save_on_errors: false, schedule: schedule)

Crie um novo pipeline a partir do cronograma e inicie sua execução.

Ativar sinalizadores de recursos

Alguns recursos iniciais do GitLab estão bloqueados atrás de prompts de recursos. Às vezes, os sinalizadores também são usados ​​para permitir a reativação temporária de recursos obsoletos.

O console é o único mecanismo pelo qual os indicadores de recursos podem ser ativados. Passe o ID de um indicador de função para Feature.enable() Função:

$ Feature.enable(:certificate_based_clusters)

A alteração é aplicada imediatamente sem reiniciar o GitLab. Este exemplo reativa o suporte para clusters Kubernetes baseados em certificado no GitLab 15.0.

Você pode verificar se um sinalizador está habilitado com um Feature.enabled?() chamar:

$ Feature.enabled?(:certificate_based_clusters)
=> true

Para desabilitar um sinalizador de recurso, passe seu ID para Feature.disable() método:

$ Feature.disable(:certificate_based_clusters)

Teste de entrega de e-mail

O console permite enviar mensagens de teste diretamente para verificar se o sistema de e-mail de saída está funcionando:

$ Notify.test_email("[email protected]", "Test subject", "Test body").deliver_now

O e-mail será enviado imediatamente usando o mesmo mecanismo das mensagens criadas pelas funções do aplicativo GitLab.

Executando scripts Ruby com Rails Runner

Uma sessão de console interativo nem sempre é necessária. Rails Runner é uma alternativa que facilita a execução de scripts Ruby no contexto do seu ambiente GitLab.

Use o gitlab-rails runner comando para executar algum código Ruby. Seu script pode fazer referência às mesmas variáveis ​​e objetos do GitLab que estão disponíveis para uma sessão do console Rails.

$ sudo gitlab-rails runner "puts User.find_by_username('demo').email"

O Rails executará o script que você fornecer e encerrará o processo. O exemplo mostrado acima gera o endereço de e-mail do usuário do GitLab chamado demo. Esta alternativa executa o código Ruby fornecido como um arquivo:

$ sudo gitlab-rails runner /scripts/gitlab-rails-script.rb

Scripts salvos como arquivos Ruby devem ser acessíveis ao Unix git Nome de usuário. O GitLab Rails sempre é executado como git:git para que scripts pertencentes a outros usuários possam falhar. Caminhos de arquivo inválidos serão interpretados como código Ruby para execução, resultando em um erro de sintaxe que pode mascarar o problema real:

$ sudo gitlab-rails runner /scripts/invalid-file.rb
Please specify a valid ruby command or the path of a script to run.
Run 'rails runner -h' for help

Resumo

O console do GitLab Rails é um utilitário poderoso para interagir diretamente com sua instância do GitLab. Pode ser uma ferramenta de depuração inestimável quando você tiver problemas com sua instalação. O console também permite que você crie scripts de tarefas administrativas usando código Ruby bruto, em vez de depender da API do GitLab. Algumas operações, como habilitar sinalizadores de recursos, só podem ser realizadas com o console.

Com o poder vem a responsabilidade. O console é capaz de contornar as medidas de segurança e aceitar operações em contextos para os quais não foi projetado. O uso incorreto pode levar à perda de dados e comportamento inesperado. Ao usar o console, você está levantando a tampa da base de código do GitLab e suas operações internas. Os métodos disponíveis e seus efeitos não são garantidos pelo suporte e podem ser alterados sem aviso prévio.