Cómo comenzar con Rails Console de GitLab para administración avanzada

La consola Rails de GitLab proporciona un terminal interactivo que le permite manipular directamente los datos en su instancia de GitLab. Puede usarlo para extraer información, solucionar problemas y realizar tareas de administración avanzadas que no son compatibles con la API o la interfaz de usuario web de GitLab.

Para acceder a la consola, debe ejecutar su propio servidor GitLab autogestionado. Necesitará privilegios de superusuario en la máquina que aloja su entorno. La consola proporciona un control sin trabas sobre GitLab y sus datos, por lo que solo los administradores de confianza deberían poder usarla. Las acciones pueden anular las medidas de seguridad normales y causar la destrucción de datos sin aviso.

Índice de contenidos
  1. Iniciar la consola
  2. Uso básico
  3. Tareas comunes
    1. Descubra los métodos disponibles en un objeto
    2. Recuperar un proyecto con sus problemas y solicitudes de combinación
    3. Recuperar a CI Pipeline
    4. Restablecer la contraseña de un administrador
    5. Hacer un proyecto de solo lectura
    6. Ejecutar manualmente un cronograma de canalización
    7. Habilitar indicadores de características
    8. Prueba de entrega de correo electrónico
  4. Ejecución de scripts de Ruby con Rails Runner
  5. Resumen

Iniciar la consola

El método utilizado para iniciar la consola depende del tipo de instalación de GitLab que esté ejecutando. Las distribuciones ómnibus instaladas desde un administrador de paquetes admiten el siguiente comando:

$ sudo gitlab-rails console

Use esta alternativa si instaló manualmente GitLab desde la fuente:

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

La consola también está disponible para instancias de GitLab nativas de la nube que se ejecutan en Kubernetes. Use Kubectl para adjuntar a GitLab's toolbox Pod e inicie una sesión de consola:

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

Las versiones de GitLab anteriores a la 14.2 tendrán un task-runner vaina en lugar de toolbox. Sustituto task-runner en el comando que se muestra arriba si está ejecutando una de estas versiones.

La consola de Rails puede tardar varios segundos en iniciarse. Mostrará un resumen de sus versiones de Ruby, GitLab y PostgreSQL antes de llevarlo a un indicador de 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>

Puede comenzar a emitir comandos de Ruby cuando vea aparecer el aviso.

Uso básico

La consola proporciona acceso al entorno Ruby on Rails de GitLab. Los objetos dentro del alcance le permiten obtener, actualizar y consultar datos en su base de datos de GitLab. Una comprensión básica de Ruby y Rails lo ayudará a comenzar.

Rails usa el patrón Active Record para proporcionar métodos de mapeo de datos estáticos en objetos. Puede llamar al siguiente método para recuperar un usuario por su nombre de usuario:

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

Puede ver las propiedades del objeto recuperado inspeccionando su attributes:

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

Para recuperar una propiedad específica, acceda a ella por su nombre:

$ demo.email
[email protected]

Puede usar los métodos de Rails para obtener convenientemente múltiples instancias de objetos que coincidan con una consulta:

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

Esto recupera todos los example.com usuarios con permisos de administrador de GitLab.

Puede cambiar las propiedades de una instancia de objeto asignando nuevos valores y llamando save:

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

los save El método verificará el objeto en un estado válido antes de guardarlo en la base de datos. Puede deshabilitar explícitamente la validación en situaciones en las que desea forzar la aplicación de un cambio en particular:

$ demo.save!(validate: false)

Esto solo debe usarse para investigar problemas en los que la interfaz de usuario web o la API de GitLab rechazan datos de forma inesperada.

Tareas comunes

La consola de GitLab Rails tiene aplicaciones ilimitadas, ya que puede trabajar con cualquier aspecto de su instancia de GitLab. Aquí hay algunas operaciones útiles para comenzar.

Descubra los métodos disponibles en un objeto

La experiencia de la consola puede ser desalentadora para los recién llegados, especialmente si no está muy familiarizado con Rails. La documentación en la consola es relativamente escasa, pero puede descubrir la funcionalidad recuperando la lista de métodos asociados con cada objeto:

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

Puedes combinar esto con grep para filtrar rápidamente a métodos con una raíz particular:

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

Esto revela que puede buscar un proyecto por su ruta con el siguiente comando:

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

Recuperar un proyecto con sus problemas y solicitudes de combinación

Primero usa el Project object para obtener el proyecto haciendo coincidir un atributo único, como su ID, ruta o URL:

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

Ahora puede acceder a los problemas del proyecto y fusionar solicitudes a través de sus propiedades de relación:

# 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)

Recuperar a CI Pipeline

los Pipeline el objeto está anidado dentro del CI espacio de nombres:

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

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

Restablecer la contraseña de un administrador

La consola puede rescatarlo si alguna vez se le bloquea el acceso a su cuenta. Recupere el objeto de usuario afectado y luego restablezca su contraseña:

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

Hacer un proyecto de solo lectura

GitLab admite proyectos de solo lectura que mantienen el repositorio accesible pero evitan que se realicen modificaciones. El modo de solo lectura debe habilitarse mediante la consola:

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

Ejecutar manualmente un cronograma de canalización

Las canalizaciones programadas se pueden ejecutar de inmediato mediante la consola. Esto a veces puede ayudar a depurar problemas que no se informan completamente en la interfaz de usuario y la API.

Primero recuperar el PipelineSchedule objeto:

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

A continuación, obtenga el usuario con el que desea ejecutar la canalización como:

$ user = User.find_by_username("demo")

Ahora use este comando para iniciar una ejecución a través del cronograma:

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

Crea una nueva canalización a partir de la programación y comienza su ejecución.

Habilitar indicadores de características

Algunas funciones preliminares de GitLab están bloqueadas detrás de indicadores de funciones. Las banderas también se utilizan a veces para permitir la reactivación temporal de capacidades obsoletas.

La consola es el único mecanismo mediante el cual se pueden habilitar los indicadores de funciones. Pase el ID de un indicador de función al Feature.enable() función:

$ Feature.enable(:certificate_based_clusters)

El cambio se aplica inmediatamente sin reiniciar GitLab. Este ejemplo reactiva la compatibilidad con clústeres de Kubernetes basados ​​en certificados en GitLab 15.0.

Puede verificar si una bandera está habilitada con un Feature.enabled?() llamar:

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

Para deshabilitar un indicador de característica, pase su ID al Feature.disable() método:

$ Feature.disable(:certificate_based_clusters)

Prueba de entrega de correo electrónico

La consola le permite enviar directamente mensajes de prueba para verificar que su sistema de correo electrónico saliente esté funcionando:

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

El correo electrónico se enviará de inmediato utilizando el mismo mecanismo que los mensajes creados por las funciones de la aplicación GitLab.

Ejecución de scripts de Ruby con Rails Runner

Una sesión de consola interactiva no siempre es necesaria. Rails Runner es una alternativa que facilita la ejecución de scripts de Ruby en el contexto de su entorno de GitLab.

Utilizar el gitlab-rails runner comando para ejecutar algún código de Ruby. Su secuencia de comandos puede hacer referencia a las mismas variables y objetos de GitLab que están disponibles para una sesión de consola de Rails.

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

Rails ejecutará el script que proporcione y luego finalizará el proceso. El ejemplo que se muestra arriba emite la dirección de correo electrónico del usuario de GitLab llamado demo. Esta alternativa ejecuta el código de Ruby proporcionado como un archivo:

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

Los scripts guardados como archivos Ruby deben ser accesibles para Unix git usuario. GitLab Rails siempre se ejecuta como git:git por lo que los scripts propiedad de otros usuarios podrían producir un error. Las rutas de archivo no válidas se interpretarán como código Ruby para ejecutar, lo que producirá un error de sintaxis que puede enmascarar el verdadero problema:

$ 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

Resumen

La consola de GitLab Rails es una poderosa utilidad para interactuar directamente con su instancia de GitLab. Puede ser una herramienta de depuración invaluable cuando experimenta problemas con su instalación. La consola también le permite realizar secuencias de comandos de tareas administrativas utilizando código Ruby sin formato, en lugar de depender de la API de GitLab. Algunas operaciones, como la habilitación de indicadores de funciones, solo se pueden lograr con la consola.

Con el poder viene la responsabilidad. La consola es capaz de ignorar las medidas de seguridad y aceptar operaciones en contextos para los que no está diseñada. El uso incorrecto podría provocar la pérdida de datos y un comportamiento inesperado. Al usar la consola, está levantando la tapa del código base de GitLab y sus operaciones internas. Los métodos disponibles y sus efectos carecen de garantía de soporte y pueden cambiar sin previo aviso.

Descubre más contenido

Subir Change privacy settings