Comment démarrer avec la console Rails de GitLab pour l'administration avancée

0
61

La console Rails de GitLab fournit un terminal interactif qui vous permet de manipuler directement les données dans votre instance GitLab. Vous pouvez l'utiliser pour extraire des informations, résoudre des problèmes et effectuer des tâches d'administration avancées qui ne sont pas prises en charge dans l'interface utilisateur Web ou l'API GitLab.

Pour accéder à la console, vous devez exécuter votre propre serveur GitLab géré. Vous aurez besoin des privilèges de superutilisateur sur la machine qui héberge votre environnement. La console offre un contrôle sans entrave sur GitLab et vos données, de sorte que seuls les administrateurs de confiance doivent être autorisés à l'utiliser. Les actions peuvent remplacer les protections normales et entraîner une destruction de données non sollicitée.

Démarrage de la console

La méthode utilisée pour démarrer la console dépend du type d'installation de GitLab que vous exécutez. Les distributions Omnibus installées à partir d'un gestionnaire de packages prennent en charge la commande suivante :

$ sudo gitlab-rails console

Utilisez cette alternative si vous avez installé manuellement GitLab à partir de la source :

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

La console est également disponible pour les instances GitLab cloud natives exécutées dans Kubernetes. Utilisez Kubectl pour vous connecter au pod de la boîte à outils de GitLab et démarrer une session de console :

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

Versions de GitLab antérieures à 14.2 aura un pod de coureur de tâches au lieu d'une boîte à outils. Remplacez task-runner dans la commande ci-dessus si vous exécutez l'une de ces versions.

Le démarrage de la console Rails peut prendre plusieurs secondes. Il affichera un résumé de vos versions de Ruby, GitLab et PostgreSQL avant de vous déposer à une invite de terminal.

$ console gitlab-rails sudo ——————————————– —————————————– Ruby : ruby ​​2.7.5p203 (2021-11-24 révision f69aeb8314 ) [x86_64-linux] GitLab : 15.0.0 (8a186dedfc1) FOSS GitLab Shell : 14.3.0 PostgreSQL : 12.10 ————————– ———————————-[ démarré en 22.48s ] Chargement de l'environnement de production (Rails 6.1.4.7) irb (principal):001:0>

Vous pouvez commencer à exécuter des commandes Ruby lorsque l'invite s'affiche.

Utilisation de base

La console permet d'accéder à l'environnement Ruby on Rails de GitLab. Les objets dans la portée vous permettent de récupérer, de mettre à jour et d'interroger des données dans votre base de données GitLab. Une compréhension de base de Ruby et Rails vous aidera à démarrer.

Rails utilise le modèle Active Record pour fournir des méthodes de mappage de données statiques sur les objets. Vous pouvez appeler la méthode suivante pour récupérer un utilisateur par son nom d'utilisateur :

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

Vous pouvez afficher les propriétés de l'objet récupéré en inspectant ses attributs :

$ pp demo.attributes {“id”=>1, “email”=>”demo@example.com”, … < p>Pour récupérer une propriété spécifique, accédez-y par son nom :

$ demo.email demo@example.com

Vous pouvez utiliser les méthodes Rails pour récupérer facilement plusieurs instances d'objet correspondant à une requête :

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

Ceci récupère tous les utilisateurs example.com avec des autorisations d'administrateur GitLab.

Vous pouvez modifier les propriétés d'une instance d'objet en attribuant de nouvelles valeurs et en appelant save :

$ demo.email = “example@example.com” $ demo.save

La méthode save vérifiera l'objet’ s dans un état valide avant de l'enregistrer dans la base de données. Vous pouvez explicitement désactiver la validation dans les situations où vous souhaitez forcer l'application d'un changement particulier :

$ demo.save!(validate : false)

Cela ne doit être utilisé que pour enquêter sur les problèmes où l'interface utilisateur Web ou l'API GitLab rejette des données de manière inattendue.

Tâches courantes

La console GitLab Rails a des applications illimitées car vous pouvez travailler avec n'importe quel aspect de votre instance GitLab. Voici quelques opérations utiles pour vous aider à démarrer.

Découvrez les méthodes disponibles sur un objet

L'expérience de la console peut être intimidante pour les nouveaux arrivants, surtout si vous n'êtes pas très familiarisé avec Rails. La documentation sur la console est relativement clairsemée mais vous pouvez découvrir les fonctionnalités en récupérant la liste des méthodes associées à chaque objet :

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

Vous pouvez combinez ceci avec grep pour filtrer rapidement les méthodes avec une racine particulière :

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

Cela révèle que vous pouvez récupérez un projet par son chemin avec la commande suivante :

$ Project.find_by_full_path(“/user/project”)

Récupérer un projet avec ses problèmes et ses demandes de fusion

< p>Utilisez d'abord l'objet Project pour obtenir le projet en faisant correspondre un attribut unique tel que son ID, son chemin ou son URL :

$ project = Project.find_by_full_path(“/user/project”)

Maintenant, vous peut accéder aux tickets du projet et aux demandes de fusion via ses propriétés de relation :

# Récupère tous les problèmes $ project.issues.all # Récupère le premier problème $ project.issues.first # Récupère une demande de fusion spécifique par son ID au niveau du projet $ project.merge_requests.find_by(iid : 10)

Récupérer un pipeline CI

L'objet Pipeline est imbriqué dans l'espace de noms CI :

# Récupère le pipeline avec l'ID 100 $ pipeline = Ci::Pipeline.find( 100) # Obtenir les builds (tâches) associées au pipeline $ jobs = pipeline.builds

Réinitialiser le mot de passe d'un administrateur

La console peut vous sauver si vous perdez l'accès à votre compte. Récupérez l'objet utilisateur concerné, puis réinitialisez son mot de passe :

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

Créer un projet Lecture seule

GitLab prend en charge les projets en lecture seule qui maintiennent le référentiel accessible mais empêchent les modifications d'être apportées. Le mode lecture seule doit être activé à l'aide de la console :

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

Exécuter manuellement une planification de pipeline

Les pipelines planifiés peuvent être exécutés immédiatement à l'aide de la console. Cela peut parfois aider à déboguer des problèmes qui ne sont pas entièrement signalés dans l'interface utilisateur et l'API.

Récupérez d'abord l'objet PipelineSchedule :

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

Récupérez ensuite l'utilisateur avec lequel vous souhaitez exécuter le pipeline :

$ user = User.find_by_username(“demo”)

Maintenant, utilisez cette commande pour démarrer une exécution via la planification :

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

Il crée un nouveau pipeline à partir du planning et commence son exécution.

Activer les indicateurs de fonctionnalité

Certaines fonctionnalités GitLab en version préliminaire sont protégées par des indicateurs de fonctionnalité. Les drapeaux sont également parfois utilisés pour permettre la réactivation temporaire de fonctionnalités obsolètes.

La console est le seul mécanisme par lequel les indicateurs de fonctionnalité peuvent être activés. Transmettez l'ID d'un indicateur de fonctionnalité à la fonction Feature.enable() :

$ Feature.enable(:certificate_based_clusters)

La modification s'applique immédiatement sans redémarrer GitLab. Cet exemple réactive la prise en charge des clusters Kubernetes basés sur des certificats dans GitLab 15.0.

Vous pouvez vérifier si un indicateur est activé avec un appel Feature.enabled?() :

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

Pour désactiver un indicateur de fonctionnalité, transmettez son ID à la méthode Feature.disable() :

$ Feature.disable(:certificate_based_clusters)

Tester la livraison des e-mails

La console vous permet d'envoyer directement des messages de test pour vérifier que votre système de messagerie sortant fonctionne :

$ Notify.test_email(“example@example.com”, “Test subject”, “Test body”).deliver_now

L'e-mail sera envoyé immédiatement en utilisant le même mécanisme que les messages créés par les fonctions de l'application GitLab.

Exécuter des scripts Ruby avec Rails Runner

Une session de console interactive n'est pas toujours nécessaire. Le Rails Runner est une alternative qui facilite l'exécution de scripts Ruby dans le contexte de votre environnement GitLab.

Utilisez la commande gitlab-rails runner pour exécuter du code Ruby. Votre script peut référencer les mêmes variables et objets GitLab qui sont disponibles pour une session de console Rails.

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

Rails exécutera le script que vous fournissez, puis terminera le processus. L'exemple ci-dessus émet l'adresse e-mail de l'utilisateur GitLab appelé demo. Cette alternative exécute le code Ruby fourni sous forme de fichier :

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

Les scripts enregistrés en tant que fichiers Ruby doivent être accessibles à l'utilisateur git Unix. GitLab Rails s'exécute toujours en tant que git:git afin que les scripts appartenant à d'autres utilisateurs puissent produire une erreur. Les chemins de fichiers non valides seront interprétés comme du code Ruby à exécuter, produisant une erreur de syntaxe qui peut masquer le véritable problème :

$ sudo gitlab-rails runner /scripts/invalid-file.rb Veuillez spécifier une commande ruby ​​valide ou le chemin d'un script à exécuter. Exécutez 'rails runner -h' pour obtenir de l'aide

Résumé

La console GitLab Rails est un utilitaire puissant pour interagir directement avec votre instance GitLab. Il peut être un outil de débogage inestimable lorsque vous rencontrez des problèmes avec votre installation. La console vous permet également de créer des scripts de tâches d'administration à l'aide de code Ruby brut, au lieu de vous fier à l'API GitLab. Certaines opérations telles que l'activation de l'indicateur de fonctionnalité ne peuvent être réalisées qu'avec la console.

Avec la puissance vient la responsabilité. La console est capable d'ignorer les barrières de sécurité et d'accepter des opérations dans des contextes pour lesquels elles ne sont pas conçues. Une utilisation incorrecte peut entraîner une perte de données et un comportement inattendu. En utilisant la console, vous soulevez le couvercle sur la base de code de GitLab et ses opérations internes. Les méthodes disponibles et leurs effets n'ont pas de garantie de support et peuvent changer sans avertissement.

LIRE LA SUITE

  • › Comment ajouter des visualisations Winamp à Spotify, YouTube, etc.
  • &rsaquo ; Quelle est la meilleure distance de visionnage de la télévision ?
  • › 10 fonctionnalités du casque VR Quest que vous devriez utiliser
  • &rsaquo ; 6 choses qui ralentissent votre Wi-Fi (et que faire à leur sujet)
  • &rsaquo ; Examen de la chaise de jeu Vertagear SL5000 : confortable, réglable, imparfaite
  • &rsaquo ; Android 13 est sorti : nouveautés et date de disponibilité