Introduction

Je suis devenu un grand fan des applications CLI ces derniers temps. C’est peut-être l’attrait du terminal de mon enfance (à commencer par DOS sur un 486/33 et le vieil Apple IIe de mon père). Je suis né un peu trop tard pour l'ère Gen X Commodore64, mais juste à temps pour en savoir plus que Windows 95. C'était une époque intéressante, à l'époque où les modems commutés et 56k étaient rois. Je sais que la plupart des articles de blog de nos jours contiennent des introductions, pour augmenter le nombre de mots pour le référencement, mais c'est même la raison pour laquelle j'aime toujours la CLI alors que tant de jeunes de nos jours ne connaissent que les applications GUI. Rien ne me rend plus heureux que de voir les enfants de la génération Z utiliser le terminal, même pour des tâches simples. Mec, attends que Gen Alpha découvre ce qu'est un BBS. « Papy ordinateurs » diront-ils probablement ?. « SORTEZ DE MA PELOUSE » ✊✊

Des projets comme CoolRetroTerm ont définitivement une place chaleureuse dans mon cœur, pour avoir ramené l'amour CLI. Je préfère toujours faire une partie de mes blogs en Micro sur mon ancien Netbook, laissez-vous vraiment vous concentrer uniquement sur l'écriture. VSCode ZenMode et MarkText se rapprochent, je suppose ?

flowchart LR
Build_App --> GH_Actions --> ??? --> Profit!!!

Conditionnement

Quoi qu'il en soit, je m'éloigne du sujet…

Alors après avoir écrit ma petite application CLI Stampy, j'ai rencontré un petit problème, comment la distribuer ? J'étais au moins assez intelligent pour réfléchir et l'écrire en GoLang (autant que je voulais simplement le construire en Python) pour éviter la colère redoutée de Python Packaging. Une chose qui m'a toujours déconcerté est la façon dont les gens publient leurs belles applications CLI sur des systèmes de gestion de paquets sophistiqués tels que APT et YUM.

Normalement, pour créer votre application, il vous suffit de faire un simple go build . et boum, binaire instantané. Aussi génial que cela soit pour le développement local, cela ne sert pas à grand-chose pour les compilations multiplateformes. Il existe de bons guides pour vous montrer comment faire, mais… tl;dr pour mon ??. Alors j’ai creusé encore, il devait y avoir un outil sympa… et bien sûr, il y a GoReleaser !

Après avoir lu une documentation très bien écrite, j'ai pu réaliser une construction multiplateforme locale rapide, très simple.

goreleaser --snapshot --clean

Réaliser des builds avec les versions de GitHub était également facile, car ils ont de belles actions GH pré-écrites !

Les utilisateurs peuvent désormais simplement installer mon application avec des outils comme eget (bon) et stew (bien mieux) !

Bien que vous puissiez également installer github.com/xxx, tout ce que cela ferait serait de cloner le dépôt, de le construire localement et de placer le bac dans votre dossier $ GOBIN. Ce n'est pas vraiment la même chose qu'un outil de gestion de paquets approprié, mais cela fonctionne à la rigueur pour les personnes qui ont déjà installé Go. Pas vraiment une option pour l'utilisateur moyen à mon humble avis. ?

Et pas seulement, GoReleaser propose également des packaging ! Alors maintenant, vous pouvez facilement créer des DEB et des RPM. J'étais un pas de plus vers le stampy apt-get install effrayé. La seule chose qui manquait était de savoir comment créer un dépôt APT. Ce dernier élément clé n’est certainement pas facile. J'ai passé environ une heure à chercher comment auto-héberger cela avec GitHub Pages, et bien que cela soit faisable, il était beaucoup plus facile d'utiliser simplement un service gratuit comme Packagecloud pour gérer la signature et l'hébergement du dépôt pour le faible coût de 0 $ par personne. mois?.

Vous pouvez voir un exemple de l'ensemble du flux de travail ICI

J'en inclurai également une version allégée ici dans un bloc de code, pour tous ceux qui tomberaient sur l'article de blog lui-même.

Pour un aperçu de haut niveau, le GHA effectue les opérations suivantes :

• Écrit la configuration de GoReleaser
• Exécute le Releaser lui-même
• Télécharge les .debs pour le prochain travail
• Dans un travail chaîné, nous extrayons le .deb et le téléchargeons sur PackageCloud
• Fait!

Exemple d'actions GitHub

name: Release

on:
  pull_request:
  push:
    # run only against tags
    tags:
      - "*"

permissions:
  contents: write
  packages: write
  issues: write

jobs:
  goreleaser:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up Go
        uses: actions/setup-go@v5
        with:
          go-version: stable

      - name: Release config
        run: |
          cat  /tmp/goreleaser-github.yaml
          project_name: EXAMPLE
          version: 2
          builds:
            - env: [CGO_ENABLED=0]
              goos:
                - linux
              goarch:
                - amd64
          nfpms:
            -
              maintainer: YOU 
              bindir: /usr/local/bin
              description: Copy formatted timestamp to system clipboard
              homepage: https://github.com/USERNAME/REPO
              license: MIT
              formats:
                - deb

          release:
            draft: false # If set to true, will not auto-publish the release.
            replace_existing_draft: true
            replace_existing_artifacts: true
            target_commitish: "{{ .Commit }}"
            prerelease: auto
            make_latest: true
            mode: replace
            include_meta: true
          EOF          

      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser
          # 'latest', 'nightly', or a semver
          version: "~> v2"
          args: release --clean --verbose --config /tmp/goreleaser-github.yaml
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Upload .deb artifact x86
        uses: actions/upload-artifact@v3
        with:
          name: deb-package
          path: dist/*amd64.deb

  pkgcld_amd64-deb:
    runs-on: ubuntu-latest
    needs:
      - goreleaser
    strategy:
      max-parallel: 3
      matrix:
        distro:
        - debian/bookworm
        - ubuntu/noble
        - ubuntu/jammy
    steps:
      - name: Download .deb artifact
        uses: actions/download-artifact@v3
        with:
          name: deb-package

      - name: Push package to packagecloud.io
        uses: computology/[email protected]
        with:
          package-name: ./*.deb
          packagecloud-username: USERNAME
          packagecloud-reponame: APP_NAME
          packagecloud-distro: ${{ matrix.distro }}
          packagecloud-token: ${{ secrets.PACKAGECLOUD_TOKEN }}

ℹ️Important

Vous devez vous assurer que des éléments tels que la structure du programme et votre fichier go.mod sont correctement configurés, sinon vous rencontrerez des problèmes pour publier correctement votre application.

Remarque : vous pouvez également distribuer votre application avec Homebrew, mais cela ne m'a pas dérangé en raison de la complexité supplémentaire des actions GH impliquant des secrets PAT et du fait que je suis assez bien couvert avec Apt, Miam, et Ragoût… savoureux ! ?

Cela m'amène à la deuxième grande chose lors de la sortie d'une application. ?DOCUMENTATION? et le très négligé Readme.md?!

Formatage Lisez-moi

Il y a quelques éléments que tout fichier Lisez-moi décent devrait avoir, car ils aideront votre application à se démarquer de toutes les applications avec peu ou pas de documentation, ou pire encore, une mauvaise documentation.

Je vous recommande fortement de suivre ce format pour créer votre propre fichier Lisez-moi ! Je suis un grand fan des badges pour le style, mais j'ai l'impression qu'avoir une petite démo GIF montre vraiment aux gens de quoi il s'agit, tout comme la liste des captures d'écran de vos applications GUI. Utiliser ASCIINEMA était assez simple, et ils disposent également d'un joli convertisseur GIF pour que tout soit parfait.

 ? Conseil

En remarque, j'ai demandé à CodeGPT de m'écrire des tests unitaires GoLang, qui, je le sais, sont normalement pénibles à écrire. C'est un plugin fantastique si vous utilisez la suite JetBrains.

Exemple Lisez-moi

• Badges de test
• Démo GIF
• Badges de couverture
• Go Bulletin
• Installer
  • Gestionnaire de packages (ex apt)
  • Installation binaire (ex eget)
  • Aller installer la capture
• Usage
  • INSTRUCTIONS CLAIRES et exemples d'extraits de code
• Paramètres
  • Où les paramètres sont enregistrés
  • Utilisez-vous des fichiers INI, JSON, Env Vars ?
• Comment accéder à l'aide intégrée
• Comment créer l'application à partir des sources
• Art antérieur (c'est-à-dire travail/inspiration précédent)

Conclure

De la même manière que lorsque j'ai commencé à apprendre à publier des applications Python, je suis heureux de pouvoir dire que je sens que je peux distribuer correctement n'importe quelle application que j'écris dans GoLang à l'avenir. C’est une compétence intéressante que j’ai acquise, et avec cet article de blog, j’espère qu’il pourra aider les autres à faire de même ! Acclamations!

-Jelloeater

 ? Mastodonte | ? Courriel | ? Commentaires | ☕ Offre-moi un café