Le tutoriel suivant explique comment utiliser des modules Go situés dans des dépôts privés (p. ex. GitHub).

Table des matières

Flux A — HTTPS avec Personal Access Token
Flux B — SSH avec clé personnelle
Flux C — SSH avec deploy key
Flux D — Hybride : deploy key (lecture) + HTTPS (écriture)
Flux E — Deploy key uniquement pour Go + HTTPS pour le développement

Introduction

En 2018, l’équipe Go a présenté les « modules » comme nouveau standard pour gérer les dépendances dans les projets Go. Un module regroupe des paquets liés qui sont versionnés ensemble et inclut tout le nécessaire pour compiler une base de code. Depuis Go 1.11, avec les Go Modules, cette gestion est devenue plus simple, plus flexible et officiellement supportée par le projet. Parmi ses principales capacités :

Gestion des versions de dépendances avec le Versionnage Sémantique (SemVer).
Commandes de gestion des dépendances simplifiées (p. ex. go get, go mod tidy).
Génération automatique d’un fichier manifeste (go.mod) avec des informations détaillées sur les dépendances.
Téléchargement automatique et mise en cache des dépendances nécessaires.

Avec les Go Modules, il n’est plus nécessaire de placer le code dans $GOPATH, contrainte qui conditionnait auparavant le développement Go. Cette approche offre une structure de projet plus flexible et facilite le travail en alternant entre différents dépôts.

Les modules Go offrent un moyen puissant de réutiliser ses propres composants et ceux de tiers dans ses programmes. La bibliothèque standard Go inclut un grand nombre de paquets, mais dans de nombreux cas des modules d’autres auteurs sont nécessaires pour des fonctions spécifiques, ou des modules développés au sein de l’organisation qui, s’agissant de logiciels propriétaires, ne doivent pas être publiés.

Cela pose un problème : un module hébergé dans un dépôt public, par exemple sur GitHub, peut être facilement installé avec :

go get github.com/gofiber/fiber/v3

Flux normal de go get (module public sur GitHub) :

┌──────────────┐
│ Développeur  │
│  go get ...  │
└──────┬───────┘
       │
       v
┌──────────────┐
│ Commande Go  │
│ (résoudre mod│
│ et version)  │
└──────┬───────┘
       │ requête
       v
┌─────────────────────────┐
│ proxy.golang.org        │
│ (zip/mod/info en cache) │
└──────┬──────────────────┘
       │ vérifie les checksums
       v
┌──────────────────────────┐
│ sum.golang.org           │
│ (transparence & intégr.) │
└──────┬───────────────────┘
       │ télécharge le module
       v
┌─────────────────────────┐
│ Cache local des modules │
│ $GOMODCACHE             │
└──────┬──────────────────┘
       │ met à jour
       v
┌─────────────────────────┐
│ go.mod / go.sum         │
└─────────────────────────┘

Mais un module situé dans un dépôt privé (p. ex. sur GitHub) échoue souvent lors de l’exécution de go get. Cela se produit parce que Go tente de résoudre les dépendances avec le proxy et la base de checksums publics par défaut, et aussi Git (utilisé en interne par go get) a besoin de credentials valides pour cloner le dépôt privé. Si vous ne configurez pas l’authentification (HTTPS avec token ou SSH) et des variables comme GOPRIVATE, le téléchargement se termine par des erreurs d’accès.

Contexte

Élément	Valeur
Dépôt	`https://github.com/myorg/my-go-module` (privé)
Consommateurs	Programmes Go internes de myorg
OS de développement	Debian 13 (Trixie)

Les développeurs appartiennent déjà à une équipe de l’organisation myorg avec la permission write sur le dépôt. Le guide suppose que chaque développeur exécute les étapes sur sa propre machine.

Quel flux me convient ?

	HTTPS + Token	SSH (clé personnelle)	SSH (deploy key)	Hybride (deploy key + HTTPS)
Authentification	Personal Access Token (PAT)	Paire de clés de l’utilisateur	Paire de clés par dépôt	Deploy key pour la lecture, PAT pour l’écriture
Portée	Tous les dépôts de l’utilisateur	Tous les dépôts de l’utilisateur	Un seul dépôt	Lecture : un dépôt ; écriture : tous les dépôts du PAT
Révocation centralisée	L’admin révoque les tokens depuis la console GitHub	L’admin retire l’utilisateur de l’équipe	L’admin supprime la deploy key du dépôt	Combine les deux mécanismes
Expiration	Obligatoire pour fine-grained, configurable pour classic	Les clés n’expirent pas par défaut	Les clés n’expirent pas par défaut	Selon le type de token et de clé
Firewalls d’entreprise	Fonctionne toujours (port 443)	Peut échouer si le port 22 est bloqué	Idem que SSH personnel	Lecture : port 22 ; écriture : port 443
Credentials par hôte	Un seul pour `github.com` ; le token doit couvrir tous les dépôts	Pas de conflit	Nécessite un alias dans `~/.ssh/config` par dépôt	Nécessite alias + credential helper
Secret sur le disque	Token dans `~/.git-credentials` (texte brut)	Clé privée dans `~/.ssh/` (avec passphrase)	Idem que SSH personnel	Les deux : clé + token
CI/CD	Plus simple : une chaîne dans un secret	Nécessite de monter le fichier de clé	Idéal : accès minimal à un seul dépôt	Peu courant en CI/CD
Qui configure	Chaque développeur crée son token	Chaque développeur crée sa clé	L’admin ajoute la clé publique ; le dev génère la paire	L’admin ajoute la deploy key ; le dev configure les deux canaux

Choisissez un flux et suivez uniquement cette section. Chacune est autonome.

Flux A — HTTPS avec Personal Access Token

A1. Paquets

sudo apt update
sudo apt install -y git golang-go

Vérifiez :

git --version   # ≥ 2.x
go version      # ≥ 1.21

A2. Personal Access Token (PAT)

Comme ~/.git-credentials stocke un seul credential par hôte, le token que vous utilisez pour github.com doit couvrir tous les dépôts avec lesquels vous travaillez (publics et privés), pas seulement my-go-module. Sinon, Git présentera le token restreint pour tout autre dépôt et vous obtiendrez une erreur 403.

Si vous avez déjà un Classic PAT avec le scope `repo`

Vous n’avez pas besoin de créer un autre token. Ce token couvre déjà tous les dépôts auxquels votre utilisateur a accès. Passez directement à l’étape A3.

Vérifiez dans Settings → Developer settings → Personal access tokens → Tokens (classic) que le scope repo est coché.

Si vous devez créer un nouveau token

Choisissez une variante :

Token fine-grained (recommandé)

Allez dans Settings → Developer settings → Personal access tokens → Fine-grained tokens → Generate new token.
Configurez :
- Token name : quelque chose de descriptif, p. ex. dev-myorg.
- Expiration : selon la politique de votre organisation.
- Resource owner : sélectionnez myorg.
- Repository access : sélectionnez All repositories.
- Permissions → Repository permissions :
  - Contents : Read and write.
  - Metadata : Read-only (activé automatiquement).
Cliquez sur Generate token et copiez le token (vous ne le reverrez plus).

Token classic

Allez dans Settings → Developer settings → Personal access tokens → Tokens (classic) → Generate new token (classic).
Configurez :
- Note : quelque chose de descriptif, p. ex. dev-myorg.
- Expiration : selon la politique de votre organisation.
- Scopes : cochez repo.
Cliquez sur Generate token et copiez le token.

A3. Credential Helper

L’objectif est que git et go get utilisent le token de façon transparente, sans vous le demander à chaque fois. Choisissez une option :

Option 1 — git-credential-store (fichier sur disque, plus simple)

git config --global credential.helper store

Si ~/.git-credentials existait déjà avec une entrée pour github.com, il faut la remplacer (Git utilise la première correspondance) :

sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null

Stockez le credential :

# Remplacez VOTRE_UTILISATEUR et VOTRE_TOKEN
printf 'protocol=https\nhost=github.com\nusername=VOTRE_UTILISATEUR\npassword=VOTRE_TOKEN\n' \
  | git credential approve

Vérifiez et protégez :

cat ~/.git-credentials
# Vous devriez voir : https://VOTRE_UTILISATEUR:VOTRE_TOKEN@github.com
chmod 600 ~/.git-credentials

Option 2 — git-credential-cache (en mémoire, plus sécurisé)

git config --global credential.helper 'cache --timeout=28800'

Il mémorisera les credentials pendant 8 heures. Vous devrez les saisir à nouveau à l’expiration ou au redémarrage.

Option 3 — gh auth (GitHub CLI)

sudo apt install -y gh
gh auth login          # Choisissez HTTPS, collez votre PAT
gh auth setup-git      # Enregistrez gh comme credential helper

A4. Forcer HTTPS pour Go

Go peut essayer d’utiliser SSH lors de la résolution des modules. Pour toujours utiliser HTTPS :

git config --global url."https://github.com/".insteadOf "ssh://git@github.com/"
git config --global url."https://github.com/".insteadOf "git@github.com:"

Vérifiez :

git config --global --get-regexp url
# url.https://github.com/.insteadof ssh://git@github.com/
# url.https://github.com/.insteadof git@github.com:

A5. Variables Go pour les modules privés

Go tente de valider les modules contre le proxy public et la base de checksums. Les deux échouent avec les dépôts privés. Listez uniquement les modules Go privés que vous utilisez comme dépendances, pas tous les dépôts de l’org :

cat >> ~/.bashrc << 'EOF'

# --- Go : modules privés de myorg ---
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF

source ~/.bashrc

Variable	Effet
`GOPRIVATE`	Indique à Go que les modules listés sont privés. Implique `GONOSUMDB` et `GONOPROXY`.
`GONOSUMDB`	Ne consulte pas `sum.golang.org` pour ces modules.
`GONOSUMCHECK`	Ne vérifie pas les checksums contre la base de données publique.

Vérifiez :

go env GOPRIVATE GONOSUMDB GONOSUMCHECK
# Les trois doivent afficher github.com/myorg/my-go-module

Note

Plusieurs modules privés : séparez-les par des virgules, sans espaces :

export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"

Répétez le même modèle pour GONOSUMDB et GONOSUMCHECK.

A6. Vérifier

# Git
git clone https://github.com/myorg/my-go-module.git /tmp/test-clone
rm -rf /tmp/test-clone

# Go
mkdir /tmp/test-go && cd /tmp/test-go
go mod init github.com/myorg/test-app
go get github.com/myorg/my-go-module@latest
rm -rf /tmp/test-go

A7. Flux de travail quotidien

git clone https://github.com/myorg/my-go-module.git
cd my-go-module

git checkout -b feature/nouvelle-fonction
# ... éditer les fichiers ...
git add .
git commit -m "feat: nouvelle fonction XYZ"
git push origin feature/nouvelle-fonction

A8. Publier une nouvelle version

git checkout main && git pull
git tag v0.2.0
git push origin v0.2.0

Les consommateurs mettent à jour avec :

go get github.com/myorg/my-go-module@v0.2.0

A9. Résumé rapide (tout en un bloc)

sudo apt install -y git golang-go

# Credential helper (option 1)
git config --global credential.helper store
sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null
printf 'protocol=https\nhost=github.com\nusername=MON_UTILISATEUR\npassword=MON_TOKEN\n' \
  | git credential approve
chmod 600 ~/.git-credentials

# Forcer HTTPS pour Go
git config --global url."https://github.com/".insteadOf "ssh://git@github.com/"
git config --global url."https://github.com/".insteadOf "git@github.com:"

# Variables Go
cat >> ~/.bashrc << 'EOF'
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF
source ~/.bashrc

A10. Résolution de problèmes

Symptôme	Cause probable	Solution
`410 Gone` lors de `go get`	Go essaie d’utiliser `proxy.golang.org`	Vérifiez que `GOPRIVATE` inclut `github.com/myorg/my-go-module`
`SECURITY ERROR` de checksums	`GONOSUMCHECK` n’est pas défini	Ajoutez `export GONOSUMCHECK="github.com/myorg/my-go-module"`
`go get` télécharge une vieille version	Cache local de Go	Exécutez `go clean -modcache` et réessayez
`fatal: could not read Username`	Credential helper non configuré	Exécutez l’étape A3
`403 Forbidden`	Token sans permissions suffisantes	Vérifiez que le PAT a la permission Contents: Read and write
`403` sur des dépôts qui fonctionnaient avant	Token fine-grained restreint à des dépôts spécifiques	Recréez avec All repositories ou utilisez un Classic PAT avec le scope `repo`
Go essaie de se connecter via SSH	Règle `insteadOf` manquante	Exécutez l’étape A4

Flux B — SSH avec clé personnelle

B1. Paquets

sudo apt update
sudo apt install -y git golang-go openssh-client

Vérifiez :

git --version   # ≥ 2.x
go version      # ≥ 1.21
ssh -V          # OpenSSH ≥ 9.x

B2. Générer la clé SSH

Si vous avez déjà une paire de clés dans ~/.ssh/id_ed25519, vous pouvez la réutiliser. Sinon :

ssh-keygen -t ed25519 -C "votre-email@exemple.com"

Acceptez le chemin par défaut et définissez une passphrase.

Vérifiez :

ls -l ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub

B3. Ajouter la clé publique à GitHub

Copiez la clé publique :

cat ~/.ssh/id_ed25519.pub

Sur GitHub :

Allez dans Settings → SSH and GPG keys → New SSH key.
Configurez :
- Title : p. ex. debian-dev-myorg.
- Key type : Authentication Key.
- Key : collez le contenu.
Cliquez sur Add SSH key.

B4. Configurer `ssh-agent`

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Pour le démarrage automatique à chaque session :

cat >> ~/.bashrc << 'AGENT'

# --- Agent SSH automatique ---
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/id_ed25519 2>/dev/null
fi
AGENT

source ~/.bashrc

B5. Forcer SSH pour Go

Go peut essayer HTTPS lors de la résolution des modules. Pour toujours utiliser SSH :

git config --global url."git@github.com:".insteadOf "https://github.com/"

Vérifiez :

git config --global --get-regexp url
# url.git@github.com:.insteadof https://github.com/

B6. Variables Go pour les modules privés

cat >> ~/.bashrc << 'EOF'

# --- Go : modules privés de myorg ---
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF

source ~/.bashrc

Vérifiez :

go env GOPRIVATE GONOSUMDB GONOSUMCHECK
# Les trois doivent afficher github.com/myorg/my-go-module

Note

Plusieurs modules privés : séparez-les par des virgules, sans espaces :

export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"

Répétez le même modèle pour GONOSUMDB et GONOSUMCHECK.

B7. Vérifier

# Connexion SSH
ssh -T git@github.com
# Réponse attendue :
# Hi VOTRE_UTILISATEUR! You've been authenticated, but GitHub does not provide shell access.

# Git
git clone git@github.com:myorg/my-go-module.git /tmp/test-clone
rm -rf /tmp/test-clone

# Go
mkdir /tmp/test-go && cd /tmp/test-go
go mod init github.com/myorg/test-app
go get github.com/myorg/my-go-module@latest
rm -rf /tmp/test-go

B8. Flux de travail quotidien

git clone git@github.com:myorg/my-go-module.git
cd my-go-module

git checkout -b feature/nouvelle-fonction
# ... éditer les fichiers ...
git add .
git commit -m "feat: nouvelle fonction XYZ"
git push origin feature/nouvelle-fonction

B9. Publier une nouvelle version

git checkout main && git pull
git tag v0.2.0
git push origin v0.2.0

Les consommateurs mettent à jour avec :

go get github.com/myorg/my-go-module@v0.2.0

B10. Résumé rapide (tout en un bloc)

sudo apt install -y git golang-go openssh-client

ssh-keygen -t ed25519 -C "votre-email@exemple.com"
#    → Téléversez ~/.ssh/id_ed25519.pub sur GitHub (Settings → SSH and GPG keys)

# Agent SSH automatique
cat >> ~/.bashrc << 'AGENT'
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/id_ed25519 2>/dev/null
fi
AGENT

# Forcer SSH pour Go
git config --global url."git@github.com:".insteadOf "https://github.com/"

# Variables Go
cat >> ~/.bashrc << 'EOF'
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF
source ~/.bashrc

B11. Résolution de problèmes

Symptôme	Cause probable	Solution
`410 Gone` lors de `go get`	Go essaie d’utiliser `proxy.golang.org`	Vérifiez que `GOPRIVATE` inclut `github.com/myorg/my-go-module`
`SECURITY ERROR` de checksums	`GONOSUMCHECK` n’est pas défini	Ajoutez `export GONOSUMCHECK="github.com/myorg/my-go-module"`
`go get` télécharge une vieille version	Cache local de Go	Exécutez `go clean -modcache` et réessayez
`Permission denied (publickey)`	Clé non chargée dans l’agent ou non enregistrée sur GitHub	Exécutez `ssh-add -l` ; vérifiez la clé sur GitHub
`ssh: connect to host github.com port 22: Connection refused`	Le pare-feu bloque le port 22	Ajoutez à `~/.ssh/config` : `Host github.com` / `Hostname ssh.github.com` / `Port 443` / `User git`
Go essaie de se connecter via HTTPS	Règle `insteadOf` manquante	Exécutez l’étape B5
`Host key verification failed`	Première connexion à GitHub	Exécutez `ssh-keyscan github.com >> ~/.ssh/known_hosts`

Flux C — SSH avec deploy key

C1. Paquets

sudo apt update
sudo apt install -y git golang-go openssh-client

Vérifiez :

git --version   # ≥ 2.x
go version      # ≥ 1.21
ssh -V          # OpenSSH ≥ 9.x

C2. Générer une paire de clés dédiée

Utilisez un nom de fichier qui identifie le dépôt :

ssh-keygen -t ed25519 -C "deploy-my-go-module" \
  -f ~/.ssh/deploy_my-go-module

Définissez une passphrase si vous le souhaitez (recommandé sur les machines de développement ; en CI/CD on la laisse généralement vide).

C3. Enregistrer la clé publique dans le dépôt

Copiez la clé publique :

cat ~/.ssh/deploy_my-go-module.pub

Sur GitHub :

Allez dans le dépôt myorg/my-go-module → Settings → Deploy keys → Add deploy key.
Configurez :
- Title : p. ex. dev-rodolfo ou ci-build-server.
- Key : collez le contenu.
- Allow write access : cochez-le si vous avez besoin de pousser. Laissez-le décoché si vous consommez seulement le module avec go get.
Cliquez sur Add key.

C4. Alias dans `~/.ssh/config`

Avec une deploy key, SSH doit savoir quelle clé utiliser pour quel dépôt. Cela se résout avec un alias d’hôte :

cat >> ~/.ssh/config << 'SSHCFG'

# --- Deploy key : myorg/my-go-module ---
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG

chmod 600 ~/.ssh/config

Directive	Fonction
`Host github-my-go-module`	Alias arbitraire que vous utiliserez dans les URLs Git et dans `insteadOf`.
`HostName github.com`	Le serveur réel auquel SSH se connectera.
`User git`	GitHub utilise toujours l’utilisateur `git` pour SSH.
`IdentityFile`	La clé privée de la deploy key.
`IdentitiesOnly yes`	Empêche `ssh-agent` de proposer d’autres clés.

C5. Configurer `ssh-agent`

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/deploy_my-go-module

Pour le démarrage automatique à chaque session :

cat >> ~/.bashrc << 'AGENT'

# --- Agent SSH automatique (deploy key my-go-module) ---
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

source ~/.bashrc

C6. Rediriger Go vers l’alias SSH

Avec les deploy keys, la règle insteadOf doit être par dépôt :

git config --global url."git@github-my-go-module:myorg/my-go-module".insteadOf \
  "https://github.com/myorg/my-go-module"

Quand Go essaie de télécharger https://github.com/myorg/my-go-module, Git le réécrira vers l’alias, SSH cherchera le bloc Host correspondant et utilisera la deploy key.

Vérifiez :

git config --global --get-regexp url
# url.git@github-my-go-module:myorg/my-go-module.insteadof https://github.com/myorg/my-go-module

C7. Variables Go pour les modules privés

cat >> ~/.bashrc << 'EOF'

# --- Go : modules privés de myorg ---
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF

source ~/.bashrc

Vérifiez :

go env GOPRIVATE GONOSUMDB GONOSUMCHECK
# Les trois doivent afficher github.com/myorg/my-go-module

Note

Plusieurs modules privés : séparez-les par des virgules, sans espaces :

export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"

Répétez le même modèle pour GONOSUMDB et GONOSUMCHECK.

C8. Vérifier

# Connexion SSH avec l'alias
ssh -T github-my-go-module
# Réponse attendue (note que c'est le DÉPÔT, pas un utilisateur) :
# Hi myorg/my-go-module! You've been authenticated, but GitHub does not
# provide shell access.

# Git
git clone git@github-my-go-module:myorg/my-go-module.git /tmp/test-clone
rm -rf /tmp/test-clone

# Go
mkdir /tmp/test-go && cd /tmp/test-go
go mod init github.com/myorg/test-app
go get github.com/myorg/my-go-module@latest
rm -rf /tmp/test-go

C9. Flux de travail quotidien

git clone git@github-my-go-module:myorg/my-go-module.git
cd my-go-module

git checkout -b feature/nouvelle-fonction
# ... éditer les fichiers ...
git add .
git commit -m "feat: nouvelle fonction XYZ"
git push origin feature/nouvelle-fonction

C10. Publier une nouvelle version

git checkout main && git pull
git tag v0.2.0
git push origin v0.2.0

Les consommateurs mettent à jour avec :

go get github.com/myorg/my-go-module@v0.2.0

C11. Résumé rapide (tout en un bloc)

sudo apt install -y git golang-go openssh-client

# Générer la deploy key
ssh-keygen -t ed25519 -C "deploy-my-go-module" -f ~/.ssh/deploy_my-go-module
#    → L'admin ajoute ~/.ssh/deploy_my-go-module.pub
#      dans myorg/my-go-module → Settings → Deploy keys

# Alias SSH
cat >> ~/.ssh/config << 'SSHCFG'
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG
chmod 600 ~/.ssh/config

# Agent SSH automatique
cat >> ~/.bashrc << 'AGENT'
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

# Rediriger Go vers l'alias SSH
git config --global url."git@github-my-go-module:myorg/my-go-module".insteadOf \
  "https://github.com/myorg/my-go-module"

# Variables Go
cat >> ~/.bashrc << 'EOF'
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF
source ~/.bashrc

C12. Résolution de problèmes

Symptôme	Cause probable	Solution
`410 Gone` lors de `go get`	Go essaie d’utiliser `proxy.golang.org`	Vérifiez que `GOPRIVATE` inclut `github.com/myorg/my-go-module`
`SECURITY ERROR` de checksums	`GONOSUMCHECK` n’est pas défini	Ajoutez `export GONOSUMCHECK="github.com/myorg/my-go-module"`
`go get` télécharge une vieille version	Cache local de Go	Exécutez `go clean -modcache` et réessayez
`ssh -T github-my-go-module` dit `Permission denied`	Clé non chargée, alias mal configuré, ou deploy key non enregistrée	Vérifiez avec `ssh-add -l` ; vérifiez `~/.ssh/config` ; confirmez la deploy key sur GitHub
`ssh -T` répond avec votre nom d’utilisateur au lieu du dépôt	`ssh-agent` propose votre clé personnelle	Ajoutez `IdentitiesOnly yes` au bloc `Host` dans `~/.ssh/config`
`go get` demande une authentification HTTPS	Règle `insteadOf` manquante	Exécutez l’étape C6
`ERROR: Repository not found`	Deploy key supprimée ou alias pointe vers le mauvais dépôt	Confirmez dans Settings → Deploy keys et vérifiez `~/.ssh/config`
`Key already in use` lors de l’ajout	GitHub ne permet pas la même clé dans plus d’un dépôt	Générez une paire distincte par dépôt
Push rejeté (`Write access denied`)	Deploy key sans permission d’écriture	L’admin active Allow write access, ou utilisez le Flux D (hybride)
`ssh: connect to host github.com port 22: Connection refused`	Le pare-feu bloque le port 22	Ajoutez à `~/.ssh/config` dans le bloc `Host` : `Hostname ssh.github.com` / `Port 443`
`Host key verification failed`	Première connexion à GitHub	Exécutez `ssh-keyscan github.com >> ~/.ssh/known_hosts`

Flux D — Hybride : deploy key (lecture) + HTTPS (écriture)

Ce flux est pour quand la deploy key est configurée en lecture seule (idéal pour go get) mais vous avez besoin de pousser pour le développement. Il combine SSH pour les lectures avec HTTPS pour les écritures.

D1. Paquets

sudo apt update
sudo apt install -y git golang-go openssh-client

Vérifiez :

git --version   # ≥ 2.x
go version      # ≥ 1.21
ssh -V          # OpenSSH ≥ 9.x

D2. Générer la deploy key

ssh-keygen -t ed25519 -C "deploy-my-go-module" \
  -f ~/.ssh/deploy_my-go-module

D3. Enregistrer la deploy key en lecture seule

Copiez la clé publique :

cat ~/.ssh/deploy_my-go-module.pub

Sur GitHub :

Allez dans myorg/my-go-module → Settings → Deploy keys → Add deploy key.
Configurez :
- Title : p. ex. dev-rodolfo-readonly.
- Key : collez le contenu.
- Allow write access : NE PAS cocher (lecture seule).
Cliquez sur Add key.

D4. Alias dans `~/.ssh/config`

cat >> ~/.ssh/config << 'SSHCFG'

# --- Deploy key : myorg/my-go-module (lecture seule) ---
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG

chmod 600 ~/.ssh/config

D5. Configurer `ssh-agent`

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/deploy_my-go-module

Pour le démarrage automatique :

cat >> ~/.bashrc << 'AGENT'

# --- Agent SSH automatique (deploy key my-go-module) ---
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

source ~/.bashrc

D6. Personal Access Token pour l’écriture

Les pushs iront via HTTPS, vous avez donc besoin d’un PAT configuré dans un credential helper. Si vous en avez déjà un qui fonctionne, vous pouvez le réutiliser. Sinon :

Créer le token

Suivez les instructions de l’étape A2 (Classic avec scope repo ou fine-grained avec All repositories et Contents: Read and write).

Configurer le credential helper

git config --global credential.helper store

# Supprimer l'entrée précédente de github.com
sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null

# Stocker le credential
printf 'protocol=https\nhost=github.com\nusername=VOTRE_UTILISATEUR\npassword=VOTRE_TOKEN\n' \
  | git credential approve

chmod 600 ~/.git-credentials

D7. Règles `insteadOf` + `pushInsteadOf`

Voici la pièce maîtresse. Git applique d’abord insteadOf, puis pushInsteadOf remplace uniquement pour les opérations d’écriture :

# Lectures (go get, git pull, git clone) → SSH deploy key
git config --global url."git@github-my-go-module:myorg/my-go-module".insteadOf \
  "https://github.com/myorg/my-go-module"

# Pushs → retour en HTTPS (utilise le PAT du credential helper)
git config --global url."https://github.com/myorg/my-go-module".pushInsteadOf \
  "git@github-my-go-module:myorg/my-go-module"

Le flux résultant :

Opération	Chaîne de réécriture	Authentification
`go get`	HTTPS → SSH (deploy key)	Deploy key, lecture seule
`git pull`	HTTPS → SSH (deploy key)	Deploy key, lecture seule
`git clone`	HTTPS → SSH (deploy key)	Deploy key, lecture seule
`git push`	HTTPS → SSH → HTTPS	PAT, lecture/écriture

Le développeur utilise des URLs HTTPS normales pour tout, et Git résout en dessous quel credential utiliser selon la direction de l’opération.

Vérifiez :

git config --global --get-regexp url
# url.git@github-my-go-module:myorg/my-go-module.insteadof https://github.com/myorg/my-go-module

D8. Variables Go pour les modules privés

cat >> ~/.bashrc << 'EOF'

# --- Go : modules privés de myorg ---
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF

source ~/.bashrc

Vérifiez :

go env GOPRIVATE GONOSUMDB GONOSUMCHECK
# Les trois doivent afficher github.com/myorg/my-go-module

Note

Plusieurs modules privés : séparez-les par des virgules, sans espaces :

export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"

Répétez le même modèle pour GONOSUMDB et GONOSUMCHECK.

D9. Vérifier

# Connexion SSH (deploy key)
ssh -T github-my-go-module
# Réponse attendue (montre le DÉPÔT, pas un utilisateur) :
# Hi myorg/my-go-module! You've been authenticated, but GitHub does not
# provide shell access.

# Go (lecture via deploy key)
mkdir /tmp/test-go && cd /tmp/test-go
go mod init github.com/myorg/test-app
go get github.com/myorg/my-go-module@latest
rm -rf /tmp/test-go

# Git clone (lecture via deploy key) + push (écriture via HTTPS)
git clone https://github.com/myorg/my-go-module.git /tmp/test-push
cd /tmp/test-push
git checkout -b test-push-verify
git commit --allow-empty -m "test: vérifier le push hybride"
git push origin test-push-verify
# Si le push fonctionne, la configuration est correcte.
# Nettoyez la branche de test :
git push origin --delete test-push-verify
rm -rf /tmp/test-push

D10. Flux de travail quotidien

# Cloner (va via deploy key grâce à insteadOf, mais transparent)
git clone https://github.com/myorg/my-go-module.git
cd my-go-module

git checkout -b feature/nouvelle-fonction
# ... éditer les fichiers ...
git add .
git commit -m "feat: nouvelle fonction XYZ"
# Le push va via HTTPS grâce à pushInsteadOf
git push origin feature/nouvelle-fonction

D11. Publier une nouvelle version

git checkout main && git pull
git tag v0.2.0
git push origin v0.2.0

Les consommateurs mettent à jour avec :

go get github.com/myorg/my-go-module@v0.2.0

D12. Résumé rapide (tout en un bloc)

sudo apt install -y git golang-go openssh-client

# --- Canal de lecture : deploy key ---

ssh-keygen -t ed25519 -C "deploy-my-go-module" -f ~/.ssh/deploy_my-go-module
#    → L'admin ajoute ~/.ssh/deploy_my-go-module.pub comme deploy key
#      en lecture seule dans myorg/my-go-module → Settings → Deploy keys

cat >> ~/.ssh/config << 'SSHCFG'
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG
chmod 600 ~/.ssh/config

cat >> ~/.bashrc << 'AGENT'
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

# --- Canal d'écriture : HTTPS + PAT ---

git config --global credential.helper store
sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null
printf 'protocol=https\nhost=github.com\nusername=MON_UTILISATEUR\npassword=MON_TOKEN\n' \
  | git credential approve
chmod 600 ~/.git-credentials

# --- Routage ---

git config --global url."git@github-my-go-module:myorg/my-go-module".insteadOf \
  "https://github.com/myorg/my-go-module"
git config --global url."https://github.com/myorg/my-go-module".pushInsteadOf \
  "git@github-my-go-module:myorg/my-go-module"

# --- Variables Go ---

cat >> ~/.bashrc << 'EOF'
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF
source ~/.bashrc

D13. Résolution de problèmes

Symptôme	Cause probable	Solution
`410 Gone` lors de `go get`	Go essaie d’utiliser `proxy.golang.org`	Vérifiez que `GOPRIVATE` inclut `github.com/myorg/my-go-module`
`SECURITY ERROR` de checksums	`GONOSUMCHECK` n’est pas défini	Ajoutez `export GONOSUMCHECK="github.com/myorg/my-go-module"`
`go get` télécharge une vieille version	Cache local de Go	Exécutez `go clean -modcache` et réessayez
`ssh -T github-my-go-module` dit `Permission denied`	Clé non chargée, alias mal configuré, ou deploy key non enregistrée	Vérifiez avec `ssh-add -l` ; vérifiez `~/.ssh/config` ; confirmez la deploy key sur GitHub
`ssh -T` répond avec votre nom d’utilisateur au lieu du dépôt	`ssh-agent` propose votre clé personnelle	Ajoutez `IdentitiesOnly yes` au bloc `Host`
`go get` échoue avec 401/403	Règle `insteadOf` manquante ; Go essaie HTTPS sans deploy key	Exécutez l’étape D7
Push rejeté (`Write access denied`)	Règle `pushInsteadOf` manquante ; le push passe par la deploy key en lecture seule	Exécutez l’étape D7
Le push demande un nom d’utilisateur/mot de passe	Credential helper non configuré ou token non stocké	Exécutez l’étape D6
Le push échoue avec 403	PAT sans permissions sur le dépôt	Vérifiez le scope `repo` (classic) ou Contents: Read and write (fine-grained)
`Key already in use`	GitHub ne permet pas la même clé dans plus d’un dépôt	Générez une paire distincte par dépôt
`ssh: connect to host github.com port 22: Connection refused`	Le pare-feu bloque le port 22	Ajoutez `Hostname ssh.github.com` et `Port 443` au bloc `Host`
`Host key verification failed`	Première connexion à GitHub	Exécutez `ssh-keyscan github.com >> ~/.ssh/known_hosts`

Flux E — Deploy key uniquement pour Go + HTTPS pour le développement

Ce flux réalise la séparation totale entre Go et git. Go utilise SSH avec la deploy key pour télécharger des modules privés. Le développeur utilise HTTPS avec son PAT pour tout le travail git (clone, pull, push). Aucun n’interfère avec l’autre.

Le problème des flux C et D est que la règle insteadOf vit dans la config globale de git (~/.gitconfig). Cela signifie que toutes les opérations git la voient, y compris celles exécutées directement par le développeur. Dans le Flux D cela est atténué avec pushInsteadOf, mais les lectures (clone, pull) passent toujours par SSH, ce qui oblige à utiliser l’alias de la deploy key pour cloner.

La solution de ce flux est de ne mettre aucune règle insteadOf dans la config globale. À la place, on utilise un wrapper shell qui injecte la règle uniquement quand Go exécute git, en utilisant les variables d’environnement GIT_CONFIG_COUNT, GIT_CONFIG_KEY_N et GIT_CONFIG_VALUE_N. Ces variables sont disponibles depuis Git 2.31 (Debian 13 fournit 2.47+). Git les traite comme configuration de priorité maximale, mais elles n’existent que pendant l’exécution de la commande enveloppée.

Le résultat :

Qui exécute	`insteadOf` actif	Protocole	Authentification
`go get`, `go build`, `go mod tidy`	Oui (via wrapper)	SSH	Deploy key (lecture seule)
`git clone`, `git pull`	Non	HTTPS	PAT (lecture/écriture)
`git push`	Non	HTTPS	PAT (lecture/écriture)

E1. Paquets

sudo apt update
sudo apt install -y git golang-go openssh-client

Vérifiez que vous avez Git ≥ 2.31, qui est la version ayant introduit le support de GIT_CONFIG_COUNT. Debian 13 fournit 2.47+, donc cela devrait être satisfait :

git --version   # ≥ 2.31 (Debian 13 fournit 2.47+)
go version      # ≥ 1.21
ssh -V          # OpenSSH ≥ 9.x

E2. Générer la deploy key

Identique aux Flux C et D : une clé dédiée avec un nom identifiant le dépôt.

ssh-keygen -t ed25519 -C "deploy-my-go-module" \
  -f ~/.ssh/deploy_my-go-module

E3. Enregistrer la deploy key en lecture seule

La seule chose que Go doit faire avec le module est le télécharger. Il n’a pas besoin d’écrire. C’est pourquoi la deploy key est enregistrée en lecture seule (privilège minimum) :

Copiez la clé publique :

cat ~/.ssh/deploy_my-go-module.pub

Sur GitHub :

Allez dans myorg/my-go-module → Settings → Deploy keys → Add deploy key.
Configurez :
- Title : p. ex. go-readonly-rodolfo.
- Key : collez le contenu.
- Allow write access : ne le cochez PAS (lecture seule).
Cliquez sur Add key.

E4. Alias dans `~/.ssh/config`

L’alias fonctionne exactement comme dans les Flux C et D. Consultez l’explication détaillée de chaque directive à l’étape C4.

cat >> ~/.ssh/config << 'SSHCFG'

# --- Deploy key : myorg/my-go-module (lecture seule, pour Go) ---
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG

chmod 600 ~/.ssh/config

E5. Configurer `ssh-agent`

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/deploy_my-go-module

Pour le démarrage automatique :

cat >> ~/.bashrc << 'AGENT'

# --- Agent SSH automatique (deploy key my-go-module) ---
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

source ~/.bashrc

E6. Personal Access Token + Credential Helper pour HTTPS

Le développeur utilise HTTPS pour tout le travail git. Le PAT et le credential helper se configurent exactement comme dans le Flux A.

Si vous avez déjà un Classic PAT avec le scope repo fonctionnel, vous pouvez le réutiliser. Si vous devez en créer un, suivez les instructions détaillées de l’étape A2.

Configurer le credential helper

git config --global credential.helper store

# Supprimer l'entrée précédente de github.com
sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null

# Stocker la credential
printf 'protocol=https\nhost=github.com\nusername=VOTRE_UTILISATEUR\npassword=VOTRE_TOKEN\n' \
  | git credential approve

chmod 600 ~/.git-credentials

Rappelez-vous que le credential helper stocke une credential par hôte, donc le token doit couvrir tous vos dépôts sur github.com.

E7. Wrapper Go avec `GIT_CONFIG_*`

Voici la pièce qui rend ce flux unique. Dans les Flux C et D, la règle insteadOf est placée dans ~/.gitconfig (config globale), où elle affecte toutes les commandes git, qu’elles soient exécutées par Go ou par le développeur. Ici, en revanche, la règle est injectée uniquement quand Go exécute git, en utilisant des variables d’environnement.

Git 2.31+ reconnaît trois variables d’environnement qui permettent d’injecter des entrées de configuration ad-hoc :

GIT_CONFIG_COUNT=N — combien d’entrées il y a
GIT_CONFIG_KEY_0, GIT_CONFIG_KEY_1, … — la clé de chaque entrée
GIT_CONFIG_VALUE_0, GIT_CONFIG_VALUE_1, … — la valeur de chaque entrée

Git traite ces entrées avec la priorité maximale (au-dessus de ~/.gitconfig et .git/config). Mais comme ce sont des variables d’environnement, elles n’existent que pendant l’exécution du processus qui les définit.

Le wrapper est une fonction shell qui enveloppe le binaire go. Chaque fois que vous tapez go dans le terminal, bash exécute la fonction au lieu du binaire directement. La fonction définit les variables GIT_CONFIG_* puis appelle le binaire réel avec command go (qui contourne la fonction et exécute le binaire du $PATH) :

cat >> ~/.bashrc << 'GOWRAP'

# --- Go : injecter insteadOf uniquement pour Go ---
go() {
    GIT_CONFIG_COUNT=1 \
    GIT_CONFIG_KEY_0="url.git@github-my-go-module:myorg/my-go-module.insteadOf" \
    GIT_CONFIG_VALUE_0="https://github.com/myorg/my-go-module" \
    command go "$@"
}
GOWRAP

source ~/.bashrc

Ce qui se passe étape par étape

Le développeur exécute go get github.com/myorg/my-go-module@latest.
Bash intercepte go et exécute la fonction wrapper.
La fonction définit GIT_CONFIG_COUNT=1, GIT_CONFIG_KEY_0 et GIT_CONFIG_VALUE_0 comme variables d’environnement du processus.
La fonction appelle le vrai binaire Go avec command go "$@".
Go a besoin de télécharger le module. Il exécute git en interne.
Git hérite des variables d’environnement de son processus parent (Go).
Git voit GIT_CONFIG_COUNT=1 et lit l’entrée de configuration injectée.
L’entrée dit : « réécris https://github.com/myorg/my-go-module en git@github-my-go-module:myorg/my-go-module ».
Git se connecte en utilisant l’alias github-my-go-module.
SSH recherche l’alias dans ~/.ssh/config, trouve la deploy key et l’utilise.
GitHub autorise la lecture. Le module est téléchargé.
Go et git se terminent. Les variables d’environnement disparaissent.

Quand le développeur exécute git clone https://github.com/myorg/my-go-module.git directement, cela ne passe pas par le wrapper. Git ne voit aucune variable GIT_CONFIG_*, n’applique aucun insteadOf, et utilise HTTPS avec le PAT du credential helper.

Vérifier que le wrapper est actif

type go
# go is a function
# go ()
# {
#     GIT_CONFIG_COUNT=1 ...
# }

S’il dit go is /usr/bin/go ou similaire, le wrapper n’a pas été chargé. Exécutez source ~/.bashrc.

Note

Plusieurs modules privés avec deploy key : incrémentez GIT_CONFIG_COUNT et ajoutez des paires KEY_N/VALUE_N supplémentaires. Chaque module a besoin de sa propre deploy key, de son alias SSH et de sa paire de variables :

go() {
    GIT_CONFIG_COUNT=2 \
    GIT_CONFIG_KEY_0="url.git@github-my-go-module:myorg/my-go-module.insteadOf" \
    GIT_CONFIG_VALUE_0="https://github.com/myorg/my-go-module" \
    GIT_CONFIG_KEY_1="url.git@github-autre-module:myorg/autre-module.insteadOf" \
    GIT_CONFIG_VALUE_1="https://github.com/myorg/autre-module" \
    command go "$@"
}

E8. Variables Go pour les modules privés

Les mêmes raisons que toujours : Go ne doit pas consulter le proxy public ni la base de checksums pour les modules privés.

cat >> ~/.bashrc << 'EOF'

# --- Go : modules privés de myorg ---
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF

source ~/.bashrc

Vérifiez :

go env GOPRIVATE GONOSUMDB GONOSUMCHECK
# Les trois doivent afficher github.com/myorg/my-go-module

Note

Plusieurs modules privés : séparez-les par des virgules, sans espaces :

export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"

Répétez le même modèle dans GONOSUMDB et GONOSUMCHECK.

E9. Vérifier

La vérification comporte deux parties indépendantes : confirmer que Go utilise la deploy key, et confirmer que git utilise HTTPS avec le PAT.

Deploy key (canal Go)

# Connexion SSH avec l'alias (doit indiquer le dépôt, pas un utilisateur)
ssh -T github-my-go-module
# Hi myorg/my-go-module! You've been authenticated, but GitHub does not
# provide shell access.

# go get utilise la deploy key via le wrapper
mkdir /tmp/test-go && cd /tmp/test-go
go mod init github.com/myorg/test-app
go get github.com/myorg/my-go-module@latest
rm -rf /tmp/test-go

HTTPS (canal de développement)

# git clone passe par HTTPS (sans insteadOf, utilise le PAT)
git clone https://github.com/myorg/my-go-module.git /tmp/test-dev
cd /tmp/test-dev

# Confirme que le remote est HTTPS pur (non réécrit en SSH)
git remote -v
# origin  https://github.com/myorg/my-go-module.git (fetch)
# origin  https://github.com/myorg/my-go-module.git (push)

# le push fonctionne par HTTPS
git checkout -b test-push-verify
git commit --allow-empty -m "test: vérifier push HTTPS"
git push origin test-push-verify
# Si ça fonctionne, la configuration est correcte.
git push origin --delete test-push-verify
rm -rf /tmp/test-dev

La vérification avec git remote -v est importante : si les URLs affichent git@github-my-go-module:... au lieu de https://..., il y a une règle insteadOf globale active qui ne devrait pas être là. Supprimez-la avec git config --global --unset.

E10. Flux de travail quotidien

Le développeur utilise HTTPS comme d’habitude. Pas besoin de savoir que Go utilise un canal différent. Tout est transparent :

# Développement : tout par HTTPS
git clone https://github.com/myorg/my-go-module.git
cd my-go-module

git checkout -b feature/nouvelle-fonction
# ... éditer les fichiers ...
git add .
git commit -m "feat: nouvelle fonction XYZ"
git push origin feature/nouvelle-fonction

# Consommation du module : Go utilise la deploy key automatiquement
# (dans tout autre projet Go de myorg)
go get github.com/myorg/my-go-module@latest

E11. Publier une nouvelle version

git checkout main && git pull
git tag v0.2.0
git push origin v0.2.0

Les consommateurs mettent à jour avec :

go get github.com/myorg/my-go-module@v0.2.0

E12. Résumé rapide (tout en un bloc)

sudo apt install -y git golang-go openssh-client

# --- Canal de lecture (Go) : deploy key ---

ssh-keygen -t ed25519 -C "deploy-my-go-module" -f ~/.ssh/deploy_my-go-module
#    → L'admin ajoute ~/.ssh/deploy_my-go-module.pub comme deploy key
#      en lecture seule dans myorg/my-go-module → Settings → Deploy keys

cat >> ~/.ssh/config << 'SSHCFG'
Host github-my-go-module
  HostName github.com
  User git
  IdentityFile ~/.ssh/deploy_my-go-module
  IdentitiesOnly yes
SSHCFG
chmod 600 ~/.ssh/config

cat >> ~/.bashrc << 'AGENT'
if [ -z "$SSH_AUTH_SOCK" ]; then
  eval "$(ssh-agent -s)" > /dev/null
  ssh-add ~/.ssh/deploy_my-go-module 2>/dev/null
fi
AGENT

# --- Canal de développement (git) : HTTPS + PAT ---

git config --global credential.helper store
sed -i '\|://.*@github\.com|d' ~/.git-credentials 2>/dev/null
printf 'protocol=https\nhost=github.com\nusername=MON_UTILISATEUR\npassword=MON_TOKEN\n' \
  | git credential approve
chmod 600 ~/.git-credentials

# --- Wrapper Go (injecte insteadOf uniquement pour Go) ---

cat >> ~/.bashrc << 'GOWRAP'
go() {
    GIT_CONFIG_COUNT=1 \
    GIT_CONFIG_KEY_0="url.git@github-my-go-module:myorg/my-go-module.insteadOf" \
    GIT_CONFIG_VALUE_0="https://github.com/myorg/my-go-module" \
    command go "$@"
}
GOWRAP

# --- Variables Go ---

cat >> ~/.bashrc << 'EOF'
# Si vous avez plusieurs modules privés, séparez-les par des virgules :
# export GOPRIVATE="github.com/myorg/my-go-module,github.com/myorg/autre-module"
export GOPRIVATE="github.com/myorg/my-go-module"
export GONOSUMDB="github.com/myorg/my-go-module"
export GONOSUMCHECK="github.com/myorg/my-go-module"
EOF
source ~/.bashrc

E13. Résolution de problèmes

Symptôme	Cause probable	Solution
`410 Gone` lors de `go get`	Go essaie d’utiliser `proxy.golang.org`	Vérifiez que `GOPRIVATE` inclut `github.com/myorg/my-go-module`
`SECURITY ERROR` de checksums	`GONOSUMCHECK` n’est pas défini	Ajoutez `export GONOSUMCHECK="github.com/myorg/my-go-module"`
`go get` télécharge une vieille version	Cache local de Go	Exécutez `go clean -modcache` et réessayez
`go get` échoue avec 401/403	Wrapper non actif ; Go essaie HTTPS sans deploy key	Vérifiez avec `type go` (doit dire « go is a function ») ; exécutez `source ~/.bashrc`
`ssh -T github-my-go-module` dit `Permission denied`	Clé non chargée, alias mal configuré, ou deploy key non enregistrée	Vérifiez avec `ssh-add -l` ; vérifiez `~/.ssh/config` ; confirmez la deploy key sur GitHub
`ssh -T` répond avec votre nom d’utilisateur au lieu du dépôt	`ssh-agent` propose votre clé personnelle	Ajoutez `IdentitiesOnly yes` au bloc `Host` dans `~/.ssh/config`
`git clone/pull` demande nom d’utilisateur/mot de passe	Credential helper non configuré	Exécutez l’étape E6
`git push` échoue avec 403	PAT sans permissions sur le dépôt	Vérifiez le scope `repo` (classic) ou Contents: Read and write (fine-grained)
`go get` fonctionne mais `git` passe aussi par SSH	Il y a une règle `insteadOf` globale active	Exécutez `git config --global --get-regexp url` et supprimez les règles superflues avec `git config --global --unset url.XXX.insteadOf`
`Key already in use`	GitHub ne permet pas la même clé dans plus d’un dépôt	Générez une paire distincte par dépôt
`ssh: connect to host github.com port 22: Connection refused`	Le pare-feu bloque le port 22	Ajoutez `Hostname ssh.github.com` et `Port 443` au bloc `Host`
`Host key verification failed`	Première connexion à GitHub	Exécutez `ssh-keyscan github.com >> ~/.ssh/known_hosts`
Le wrapper ne s’active pas dans les scripts ou le CI	Les scripts non-interactifs ne chargent pas `~/.bashrc`	Utilisez `source ~/.bashrc` au début du script, ou exportez les variables `GIT_CONFIG_*` directement dans l’environnement CI

Comment utiliser des modules Go depuis des dépôts GitHub privés.

Table des matières

Introduction

Contexte

Quel flux me convient ?

Flux A — HTTPS avec Personal Access Token

A1. Paquets

A2. Personal Access Token (PAT)

Si vous avez déjà un Classic PAT avec le scope repo

Si vous devez créer un nouveau token

A3. Credential Helper

A4. Forcer HTTPS pour Go

A5. Variables Go pour les modules privés

A6. Vérifier

A7. Flux de travail quotidien

A8. Publier une nouvelle version

A9. Résumé rapide (tout en un bloc)

A10. Résolution de problèmes

Flux B — SSH avec clé personnelle

B1. Paquets

B2. Générer la clé SSH

B3. Ajouter la clé publique à GitHub

B4. Configurer ssh-agent

B5. Forcer SSH pour Go

B6. Variables Go pour les modules privés

B7. Vérifier

B8. Flux de travail quotidien

B9. Publier une nouvelle version

B10. Résumé rapide (tout en un bloc)

B11. Résolution de problèmes

Flux C — SSH avec deploy key

C1. Paquets

C2. Générer une paire de clés dédiée

C3. Enregistrer la clé publique dans le dépôt

C4. Alias dans ~/.ssh/config

C5. Configurer ssh-agent

C6. Rediriger Go vers l’alias SSH

C7. Variables Go pour les modules privés

C8. Vérifier

C9. Flux de travail quotidien

C10. Publier une nouvelle version

C11. Résumé rapide (tout en un bloc)

C12. Résolution de problèmes

Flux D — Hybride : deploy key (lecture) + HTTPS (écriture)

D1. Paquets

D2. Générer la deploy key

D3. Enregistrer la deploy key en lecture seule

D4. Alias dans ~/.ssh/config

D5. Configurer ssh-agent

D6. Personal Access Token pour l’écriture

Créer le token

Configurer le credential helper

D7. Règles insteadOf + pushInsteadOf

D8. Variables Go pour les modules privés

D9. Vérifier

D10. Flux de travail quotidien

D11. Publier une nouvelle version

D12. Résumé rapide (tout en un bloc)

D13. Résolution de problèmes

Flux E — Deploy key uniquement pour Go + HTTPS pour le développement

E1. Paquets

E2. Générer la deploy key

E3. Enregistrer la deploy key en lecture seule

E4. Alias dans ~/.ssh/config

E5. Configurer ssh-agent

E6. Personal Access Token + Credential Helper pour HTTPS

Configurer le credential helper

E7. Wrapper Go avec GIT_CONFIG_*

Ce qui se passe étape par étape

Vérifier que le wrapper est actif

E8. Variables Go pour les modules privés

E9. Vérifier

Deploy key (canal Go)

HTTPS (canal de développement)

E10. Flux de travail quotidien

E11. Publier une nouvelle version

E12. Résumé rapide (tout en un bloc)

E13. Résolution de problèmes

Si vous avez déjà un Classic PAT avec le scope `repo`

B4. Configurer `ssh-agent`

C4. Alias dans `~/.ssh/config`

C5. Configurer `ssh-agent`

D4. Alias dans `~/.ssh/config`

D5. Configurer `ssh-agent`

D7. Règles `insteadOf` + `pushInsteadOf`

E4. Alias dans `~/.ssh/config`

E5. Configurer `ssh-agent`

E7. Wrapper Go avec `GIT_CONFIG_*`