---
title: "Git-Proxy-Einstellungen: Git hinter einem Proxy nutzen"
description: "Den Git-Proxy setzen Sie mit git config --global http.proxy http://user:pass@host:port. Dazu: Regeln pro Host, NO_PROXY, socks5h, SSH-Remotes und Fehler."
url: https://proxynet.io/de/blog/git-proxy-settings
date: 2026-11-19
author: "Acar Diveroli"
category: "Anleitungen"
lang: de
---

# Git-Proxy-Einstellungen: Git hinter einem Proxy nutzen

Auf einem neuen Arbeitslaptop hängt `git clone` zwanzig Sekunden lang und gibt dann mit `Failed to connect to … :443` auf. Der Browser auf demselben Rechner öffnet die Seite des Repositorys ohne Probleme, denn der Browser kennt den Firmenproxy, Git aber nicht. Dasselbe passiert auf einem Build-Server, der nur über ein einziges Gateway nach draußen darf, oder wenn ein selbst betriebener Git-Server nur Verbindungen von einer einzigen freigegebenen Adresse annimmt.

Dieser Leitfaden behandelt `http.proxy` und seine Geltungsbereiche, Regeln pro Host, die Umgebungsvariablen, die Git liest, und welche davon gewinnt, außerdem SOCKS5, Anmeldedaten mit Sonderzeichen, SSH-Remotes, das Entfernen von Einstellungen und die genauen Fehlertexte. Jeden Befehl haben wir mit Git 2.56 unter Windows 11 gegen kleine Testproxys auf 127.0.0.1 ausgeführt, mit einer Wegwerf-Konfigurationsdatei, sodass sich keine echte Git-Einstellung geändert hat.

> **Hinweis: Kurzantwort**
>
> Führen Sie `git config --global http.proxy http://user:pass@pr.proxynet.io:8000` aus, um jedes `clone`, `fetch` und `push` über HTTPS durch einen Proxy zu schicken, und prüfen Sie das Ergebnis mit `git config --global --get http.proxy`. Mit `http.https://git.example.com.proxy` beschränken Sie den Proxy auf einen Server; setzen Sie diesen Schlüssel auf eine leere Zeichenkette, nehmen Sie den Host aus. Die Einstellung überschreibt `https_proxy` und `all_proxy`, während `NO_PROXY` die dort aufgeführten Hosts weiterhin ausnimmt. Für einen SOCKS5-Proxy, der auch Hostnamen auflösen soll, verwenden Sie `socks5h://`. Remotes, die mit `git@` beginnen, nutzen SSH; SSH ignoriert `http.proxy` und braucht stattdessen `ProxyCommand` oder `ProxyJump`.

## Wann braucht Git einen Proxy?

Git braucht einen Proxy immer dann, wenn das Netz das Remote-Repository nicht direkt erreichen lässt oder wenn das Remote nur eine bekannte Adresse annimmt: ein Firmennetz mit ausgehendem Proxy, ein CI-Runner in einem abgeschotteten Subnetz, ein selbst betriebener Git-Server, der eine einzige IP auf seiner Allowlist führt. Oft funktioniert der Browser, während Git scheitert, denn der Browser folgt dem System-Proxy, und Git liest nur seine eigene Konfiguration und ein paar Umgebungsvariablen.

Git kennt drei Wege, mit einem Remote zu sprechen, und jeder bezieht seinen Proxy aus einer anderen Quelle. Bevor Sie etwas ändern, sehen Sie sich mit `git remote -v` die URL des Remotes an.

## Wie leitet Git Verkehr über einen Proxy?

Git übergibt HTTP- und HTTPS-Remotes an libcurl, die Bibliothek hinter dem Befehl `curl`; HTTPS-Verkehr folgt also dem üblichen Proxy-Ablauf:

1. **Git liest die Proxy-Adresse** aus `http.<url>.proxy`, dann aus `http.proxy`, dann aus den Umgebungsvariablen, und gleicht den Host mit `NO_PROXY` ab.
2. **Es öffnet eine TCP-Verbindung zum Proxy** und sendet für ein `https://`-Remote `CONNECT git.example.com:443`. Unser Testproxy protokollierte genau diese Zeile, mit dem User-Agent `git/2.56.0.windows.4`.
3. **Antwortet der Proxy mit `407`**, wiederholt Git das `CONNECT` mit einem `Proxy-Authorization`-Header, den es aus den Anmeldedaten in der Proxy-URL bildet.
4. **Nach `200 Connection established` läuft TLS innerhalb des Tunnels.** Der Proxy sieht Hostnamen und Port, nicht den Inhalt des Repositorys.
5. **Der Git-Server sieht die Ausgangs-IP des Proxys**, und genau diese Adresse prüft eine Allowlist.

| Remote-URL | Transport | Proxy-Einstellung |
|---|---|---|
| `https://git.example.com/team/app.git` | HTTPS über libcurl | `http.proxy`, Umgebungsvariablen |
| `http://git.example.com/team/app.git` | HTTP über libcurl | `http.proxy`, `http_proxy` |
| `git@git.example.com:team/app.git` | SSH | `ProxyCommand`, `ProxyJump` |
| `ssh://git@git.example.com/team/app.git` | SSH | `ProxyCommand`, `ProxyJump` |
| `git://git.example.com/app.git` | Git-Protokoll | `core.gitProxy` |

## Wie richten Sie in Git einen Proxy ein?

Setzen Sie `http.proxy` mit `git config`. Der Wert ist eine URL der Form `[protocol://][user[:password]@]proxyhost[:port]`, wie die [git-config-Dokumentation](https://git-scm.com/docs/git-config) sie festlegt:

```bash
git config --global http.proxy http://user:pass@pr.proxynet.io:8000
git config --global --get http.proxy
```

Auf unserem Testrechner gab der zweite Befehl dieselbe URL zurück, und die Konfigurationsdatei erhielt einen Abschnitt `[http]` mit einer Zeile `proxy =`.

Einen eigenen Schlüssel `https.proxy` gibt es in Git nicht. `http.proxy` deckt HTTP- und HTTPS-Remotes ab, und das `http://` am Anfang des Werts beschreibt, wie Git mit dem Proxy spricht, nicht mit dem Remote. Ein Proxy, der selbst TLS erwartet, bekommt einen `https://`-Wert, und `http.proxySSLCAInfo` nennt das Zertifikatsbündel, mit dem Git ihn prüft.

### Geltungsbereich: global, System oder Repository

Die Option entscheidet, welche Datei die Zeile erhält:

- **`--global`** schreibt in `~/.gitconfig` und gilt für jedes Repository Ihres Benutzerkontos.
- **`--system`** schreibt in die Datei `etc/gitconfig` der Installation und gilt für jeden Benutzer des Rechners.
- **`--local`**, der Standard ohne Option, schreibt in `.git/config` und gilt nur für das aktuelle Repository.

Steht derselbe Schlüssel in mehreren Dateien, schlägt der Wert des Repositorys den globalen und dieser den des Systems. Ein Kollege, der „den Proxy gesetzt hat“ und trotzdem nicht klonen kann, hat den Befehl oft in einem einzelnen Repository ausgeführt, ohne `--global`.

### Nur für einen Befehl

Um einen Proxy zu testen, ohne etwas zu speichern, übergeben Sie ihn mit `-c` vor dem Unterbefehl:

```bash
git -c http.proxy=http://user:pass@pr.proxynet.io:8000 ls-remote https://git.example.com/team/app.git
```

`git ls-remote` listet nur die Branches eines Remotes auf und ist deshalb ein schneller, harmloser Verbindungstest.

## Wie nutzen Sie einen Proxy nur für einen Host?

Schreiben Sie die Adresse des Remotes in den Schlüssel: `http.<url>.proxy`. Git vergleicht jede Anfrage-URL mit diesen Schlüsseln und nimmt den besten Treffer; so erreicht ein Rechner einen externen Host über den Proxy und einen internen direkt:

```bash
# Proxy nur für diesen Host
git config --global http.https://git.example.com.proxy http://user:pass@pr.proxynet.io:8000

# globaler Proxy, aber nie für den internen Server
git config --global http.proxy http://user:pass@pr.proxynet.io:8000
git config --global http.https://git.internal.example.proxy ""
```

Ein leerer Wert schaltet den Proxy für diese Adresse ab. In unserem Test wurde der ausgenommene Host direkt angesprochen, obwohl `http.proxy` und die Variable `https_proxy` beide auf einen Proxy zeigten, und `git config --get-urlmatch http.proxy <url>` gab für ihn eine leere Zeile aus und für jeden anderen Host den Proxy.

Der Abgleich folgt einer festen Reihenfolge: Schema, Host, Port, Pfad, Benutzername. Ein `*` im Host passt auf genau eine Ebene von Subdomains (`https://*.example.com` erfasst `git.example.com`, aber nicht `a.b.example.com`), und ein längerer Pfad schlägt einen kürzeren. Ein Remote kann auch einen eigenen Wert `remote.origin.proxy` tragen; eine leere Zeichenkette dort schaltet den Proxy für dieses Remote ab.

## Nutzt Git HTTP_PROXY, HTTPS_PROXY und NO_PROXY?

Ja. Ist `http.proxy` nicht gesetzt, nimmt Git den Proxy aus denselben Umgebungsvariablen wie curl: `https_proxy` für HTTPS-Remotes, `http_proxy` für HTTP-Remotes und `all_proxy` als Rückfall für beide. `NO_PROXY` enthält eine kommagetrennte Liste von Hosts, die ohne Proxy erreicht werden sollen.

Wir haben die Variablen und die Konfiguration auf zwei verschiedene Testproxys gesetzt und beobachtet, welcher das `CONNECT` erhielt:

| Aufbau | Ergebnis |
|---|---|
| `https_proxy` und `http.proxy` beide gesetzt | `http.proxy` genutzt |
| Nur `HTTPS_PROXY` (Großbuchstaben) | Proxy genutzt |
| Nur `HTTP_PROXY`, HTTPS-Remote | Direkt verbunden |
| Nur `all_proxy` | Proxy genutzt |
| `http.proxy` plus `NO_PROXY=.internal.test` | Direkt verbunden |

Zwei Zeilen überraschen viele. `HTTP_PROXY` allein bewirkt bei einem HTTPS-Remote nichts, das Klonen geht also direkt hinaus. Und `NO_PROXY` nimmt Hosts auch von einem Proxy aus, der in der Git-Konfiguration steht: praktisch für interne Server, verwirrend, wenn ein veralteter Wert in Ihrem Shell-Profil liegt. Seine Einträge passen auf den Host selbst und auf jeden Host unter dieser Domain, daher erfasst `internal.test` auch `git.internal.test`.

Unter Linux und macOS zählt die Groß- und Kleinschreibung. Die [curl-Dokumentation zu Proxys](https://everything.curl.dev/usingcurl/proxies/env.html) erklärt, dass `http_proxy` nur kleingeschrieben gelesen wird, weil ein Webserver, der ein CGI-Skript ausführt, einen eingehenden `Proxy:`-Header in eine großgeschriebene Variable `HTTP_PROXY` verwandelt; die anderen Proxy-Variablen funktionieren in beiden Schreibweisen. Auf unserem Windows-Rechner funktionierte auch die großgeschriebene Form, da Windows bei Variablennamen nicht zwischen Groß- und Kleinschreibung unterscheidet.

## Wie nutzen Sie einen SOCKS5-Proxy mit Git?

Schreiben Sie ein SOCKS-Schema in denselben Schlüssel `http.proxy`. libcurl akzeptiert `socks4://`, `socks4a://`, `socks5://` und `socks5h://`, und die letzten beiden unterscheiden sich darin, wo der Hostname aufgelöst wird:

```bash
git config --global http.proxy socks5h://user:pass@pr.proxynet.io:1080
```

Mit `socks5://` ermittelt Git die IP-Adresse des Remotes auf Ihrem Rechner und bittet den Proxy, sich mit dieser Nummer zu verbinden. Mit `socks5h://` sendet es den Hostnamen, und der Proxy löst ihn auf. Unser SOCKS-Testserver machte den Unterschied sichtbar: Dasselbe `ls-remote` kam mit `socks5://` als `CONNECT IPv4 104.20.23.154 port 443` an und mit `socks5h://` als `CONNECT DOMAIN example.com port 443`.

Nutzen Sie `socks5h://`, wenn Ihr Netz externe Namen nicht auflösen kann oder DNS-Abfragen nicht von Ihrem Rechner ausgehen sollen. Die [libcurl-Referenz zu Proxys](https://curl.se/libcurl/c/CURLOPT_PROXY.html) weist außerdem darauf hin, dass eine Proxy-URL ohne Port standardmäßig 1080 verwendet; schreiben Sie den Port Ihres Endpunkts also immer aus.

Auch ein Endpunkt für [SOCKS5-Proxy](https://proxynet.io/de/socks5-proxy) passt in denselben Schlüssel.

Wie das Protokoll Schritt für Schritt arbeitet, erklärt [Was ist ein SOCKS5-Proxy?](/de/blog/socks5-proxy-101).

## Wie übergeben Sie Proxy-Anmeldedaten sicher?

Schreiben Sie Benutzername und Passwort in die Proxy-URL und kodieren Sie jedes Zeichen, das in einer URL eine Bedeutung hat, per Prozentkodierung. Die häufigsten sind `@` als `%40`, `:` als `%3A`, `#` als `%23`, `/` als `%2F` und ein Leerzeichen als `%20`:

```bash
# Passwort p@ss:w#rd
git config --global http.proxy "http://user:p%40ss%3Aw%23rd@pr.proxynet.io:8000"
```

Auf unserem Testproxy kam die kodierte Form als `user:p@ss:w#rd` an, genau wie beabsichtigt. Die rohe Form `http://user:p@ss:w#rd@…` erreichte den Proxy nie: Git brach mit `Invalid proxy URL … only SOCKS proxies support paths` ab, weil das erste `@` und das `#` die URL zerlegten.

Ein Passwort in `~/.gitconfig` liegt im Klartext, daher gibt es zwei sauberere Wege. Lassen Sie das Passwort weg (`http://user@pr.proxynet.io:8000`), dann fragt Git es über sein Credential-System ab, dasselbe, das auch die Anmeldungen für Repositorys speichert; bei abgeschalteten Eingabeaufforderungen endete unser Lauf mit `could not read Password … terminal prompts disabled`. Oder verzichten Sie ganz auf Anmeldedaten: Steht die IP des Rechners auf der Whitelist des Proxys, lautet die URL einfach `http://pr.proxynet.io:8000`. Proxynet akzeptiert bis zu 10 IPs auf der Whitelist, was gut zu einem Build-Server mit fester Adresse passt.

### anyauth oder basic?

`http.proxyAuthMethod` legt fest, wie Git sich anmeldet. Der Standard `anyauth` sendet das `CONNECT` zuerst ohne Anmeldedaten und wartet auf eine `407`, die die akzeptierten Verfahren nennt; `basic` schickt Benutzername und Passwort schon mit der ersten Anfrage. Unsere Testproxys zeigten, wann das eine Rolle spielt:

| Verhalten des Proxys | `anyauth` (Standard) | `basic` |
|---|---|---|
| 407 mit Challenge, Verbindung bleibt offen | Funktioniert, zwei Anfragen | Funktioniert, eine Anfrage |
| 407 mit Challenge, danach geschlossen | `Proxy CONNECT aborted` | Funktioniert |
| 407 ohne `Proxy-Authenticate` | `response 407` | Funktioniert |

Sehen Sie `Proxy CONNECT aborted` trotz richtigem Passwort, versuchen Sie zuerst `git config --global http.proxyAuthMethod basic`. Basic sendet das Passwort Base64-kodiert, nicht verschlüsselt; nutzen Sie es also nur in Netzen, denen Sie vertrauen.

## Funktioniert http.proxy für SSH-Remotes?

Nein. Ein Remote wie `git@git.example.com:team/app.git` läuft über SSH, und Git startet dafür das Programm `ssh`; `http.proxy` und die Proxy-Variablen werden dabei nie gelesen. Mit gesetztem `http.proxy` ignorierte unser SSH-Test den Proxy vollständig und scheiterte mit `ssh: Could not resolve hostname`. Ist SSH selbst neu für Sie, erklärt [Was ist SSH?](/de/blog/what-is-ssh) Schlüssel und Host-Prüfung.

SSH hat zwei eigene Proxy-Optionen, beschrieben im [ssh_config-Handbuch](https://man.openbsd.org/ssh_config):

- **`ProxyCommand`** startet ein Hilfsprogramm, das die Verbindung über einen Proxy öffnet; `%h` und `%p` stehen für Zielhost und Port. Das OpenBSD-`nc`, das auf vielen Linux- und macOS-Systemen vorhanden ist, erledigt das: `ProxyCommand nc -X connect -x pr.proxynet.io:8000 %h %p` für einen HTTP-Proxy, `-X 5` für SOCKS5. Laut seinem Handbuch funktioniert Proxy-Authentifizierung nur mit HTTP-CONNECT-Proxys, daher ist eine IP-Whitelist hier der einfachere Weg.
- **`ProxyJump`** leitet die Verbindung nicht über einen Webproxy, sondern über einen anderen SSH-Server (einen Jump-Host oder Bastion-Host): `ProxyJump user@jump.example.com`.

Schreiben Sie die Zeile unter einen `Host`-Block in `~/.ssh/config`, damit nur der Git-Server sie nutzt:

```text
Host git.example.com
    ProxyCommand nc -X 5 -x pr.proxynet.io:1080 %h %p
```

Für ein einzelnes Repository oder einen einzelnen Befehl übergeben Sie die Option stattdessen über `core.sshCommand` oder die Variable `GIT_SSH_COMMAND`. Auf unserem Testrechner nutzten wir `connect`, ein kleines Hilfsprogramm, das in der Git-Umgebung dieses Rechners vorhanden war, und die Proxys protokollierten `CONNECT DOMAIN git.internal.test port 22` (SOCKS5) und `CONNECT git.internal.test:22` (HTTP). Manche HTTP-Proxys erlauben `CONNECT` nur zu Port 443; prüfen Sie also, ob Port 22 zugelassen ist, oder stellen Sie das Remote auf HTTPS um. Das alte Protokoll `git://` hat einen eigenen Schalter, `core.gitProxy`, den man heute selten braucht.

## Wie prüfen und entfernen Sie die Git-Proxy-Einstellungen?

Lesen Sie zuerst den Wert, einschließlich seiner Herkunft. Diese Befehle beantworten die meisten Fragen der Art „Warum nutzt Git noch den alten Proxy?“:

```bash
git config --get http.proxy                     # Wert, den Git in diesem Repository nutzt
git config --show-origin --get-all http.proxy   # jeder Wert und die Datei, in der er steht
git config --get-urlmatch http.proxy https://git.example.com/team/app.git
env | grep -i proxy                             # Variablen (PowerShell: Get-ChildItem env:*proxy*)
```

Entfernen Sie einen Wert mit `--unset` im selben Geltungsbereich, in dem Sie ihn gesetzt haben:

```bash
git config --global --unset http.proxy
git config --global --unset http.https://git.example.com.proxy
git config --global --unset-all http.proxy      # falls der Schlüssel mehrfach vorkommt
```

Ist ein Schlüssel doppelt eingetragen, verweigert ein einfaches `--unset` den Dienst mit `warning: http.proxy has multiple values`; `--unset-all` entfernt beide Einträge. Variablen entfernen Sie mit `unset https_proxy` in bash oder `Remove-Item Env:https_proxy` in PowerShell; löschen Sie außerdem die Profilzeile, die sie gesetzt hat.

Um das Gespräch mit dem Proxy mitzulesen, führen Sie einen Befehl mit `GIT_TRACE_CURL=1` aus. Git schwärzt den Header `Proxy-Authorization` in diesem Trace standardmäßig, behandeln Sie die Ausgabe aber trotzdem als vertraulich.

## Welcher Proxy passt zu Git-Verkehr?

Ein Proxy mit fester Ausgangsadresse passt am besten zu Git, denn der übliche Grund, Git über einen Proxy eines Drittanbieters zu leiten, ist eine Allowlist auf dem Git-Server, auf einem Paketspiegel oder in einem Partnernetz. Ein [Datacenter-Proxy](https://proxynet.io/de/datacenter-proxy) liefert eine dedizierte IPv4-Adresse, die über Klonvorgänge und Neustarts hinweg gleich bleibt; der Eintrag in der Allowlist wird also nur einmal geschrieben. Rotierende Adressen arbeiten gegen dieses Ziel.

Pro IP verkaufte Produkte wie Datacenter-Proxys kommen standardmäßig mit einer Zielseiten-Beschränkung, und der Zugriff auf alle Websites ist eine kostenpflichtige Zusatzoption; prüfen Sie also, ob Ihr Git-Host über Ihre IPs erreichbar ist, bevor Sie ihn in die CI einbinden. In einem Firmennetz bleibt der Proxy Ihrer IT-Abteilung die richtige Antwort.

## Wo Ihnen Git-Proxy-Einstellungen begegnen

Firmenlaptops sind der klassische Fall: Jede ausgehende Verbindung passiert einen prüfenden Proxy, und Git erfährt davon einmal in der globalen Konfiguration. Danach kommen CI-Runner, meist über Umgebungsvariablen in der Job-Definition, damit Git, der Paketmanager und curl eine gemeinsame Einstellung teilen. Selbst betriebene Git-Server und Artefakt-Spiegel, die nur eine kurze Liste von Quelladressen annehmen, brauchen eine stabile Ausgangs-IP, und Teams, die über einen Bastion-Host arbeiten, treffen auf die SSH-Seite, wo `ProxyJump` jeden Webproxy ersetzt.

## Häufige Git-Proxy-Fehler und ihre Lösungen

Die folgenden Texte gab Git 2.56 mit libcurl 8.23 auf unserem Testrechner nach `fatal: unable to access '<url>':` aus. Ältere curl-Versionen formulieren einige davon leicht anders.

- **`Failed to connect to git.example.com:443 over proxy 127.0.0.1 after 0 ms: Could not connect to server`.** Der Proxy selbst ist nicht erreichbar: falscher Port, eine Firewall, oder der Proxy ist ausgefallen.
- **Dieselbe Meldung ohne `over proxy`.** Git hat gar keinen Proxy genutzt. Prüfen Sie `--show-origin --get-all http.proxy`, das Schema der URL und `NO_PROXY`.
- **`Could not resolve proxy: proxy.invalid`.** Der Hostname des Proxys lässt sich nicht auflösen.
- **`Could not resolve host: git.example.com`.** Git hat sich direkt verbunden, oder ein `socks5://`-Proxy braucht eine Namensauflösung, die Ihr Netz nicht leisten kann. Setzen Sie den Proxy oder nutzen Sie `socks5h://`.
- **`CONNECT tunnel failed, response 407`.** Der Proxy hat die Anmeldedaten abgelehnt oder keine erhalten. Prüfen Sie Benutzernamen, Kodierung des Passworts und die IP-Whitelist; [HTTP 407 Proxy Authentication Required beheben](/de/blog/http-407-proxy-authentication-required) geht jede Ursache durch.
- **`Proxy CONNECT aborted`.** Oft scheitert hier der `anyauth`-Handshake an einem Proxy, der die Verbindung nach seiner 407 schließt. Setzen Sie `http.proxyAuthMethod` auf `basic`.
- **`Invalid proxy URL … only SOCKS proxies support paths`.** Ein unkodiertes `@`, `#` oder `/` steht im Passwort.
- **`cannot complete SOCKS5 connection to … (2)`.** Der SOCKS-Proxy hat das Ziel abgelehnt; die Zahl ist der Antwortcode von SOCKS (2 bedeutet „durch das Regelwerk nicht erlaubt“).
- **`SSL certificate problem: unable to get local issuer certificate`.** Ein Proxy mit TLS-Inspektion signiert den Verkehr mit einem Firmenzertifikat neu, dem Git nicht vertraut. Lassen Sie `http.sslCAInfo` auf ein Bündel mit dem Stammzertifikat der Firma zeigen, oder setzen Sie unter Git for Windows `http.sslBackend` auf `schannel`, um den Zertifikatspeicher von Windows zu nutzen.
- **Lange Wartezeit, die in einem Timeout endet.** Eine Firewall verwirft die Pakete, meist weil Git sich direkt verbindet, in einem Netz, das nur den Weg über den Proxy zulässt.

`http.sslVerify false` und `GIT_SSL_NO_VERIFY` blenden den Zertifikatsfehler aus, indem sie genau die Prüfung abschalten, die Sie vor einem Man-in-the-Middle-Angriff schützt. Nutzen Sie sie höchstens für einen einzelnen Diagnosebefehl, nie als Lösung.

## Entscheidungshilfe

| Bedarf | Empfehlung |
|---|---|
| Alle HTTPS-Remotes über einen Proxy | `git config --global http.proxy` |
| Nur ein externer Host | `http.<url>.proxy` |
| Interner Server ohne Proxy | Leeres `http.<url>.proxy` oder `NO_PROXY` |
| CI-Job, mehrere Tools | Variablen `https_proxy` und `NO_PROXY` |
| SOCKS5 mit DNS-Auflösung beim Proxy | `socks5h://` in `http.proxy` |
| Kein Passwort in Konfigurationsdateien | IP-Whitelist oder nur Benutzername |
| `Proxy CONNECT aborted` | `http.proxyAuthMethod basic` |
| Remotes mit `git@` oder `ssh://` | `ProxyCommand` oder `ProxyJump` |
| TLS-Inspektion in der Firma | `http.sslCAInfo` oder `schannel` |

## Häufige Fragen

### Wie richte ich in Git einen Proxy ein?

Führen Sie `git config --global http.proxy http://host:port` aus und setzen Sie `user:pass@` vor den Host, wenn der Proxy eine Anmeldung verlangt. Die Einstellung gilt für jedes HTTP- und HTTPS-Remote Ihres Kontos; prüfen Sie sie mit `git config --global --get http.proxy`.

### Wie entferne ich den Proxy aus Git?

Führen Sie `git config --global --unset http.proxy` aus, mit derselben Bereichsoption, mit der Sie ihn gesetzt haben. Nutzt Git weiterhin einen Proxy, suchen Sie mit `git config --show-origin --get-all http.proxy` nach einem Wert im Repository und in Ihrer Umgebung nach `https_proxy` oder `all_proxy`.

### Gibt es in git config eine Einstellung https.proxy?

Nein. Die Git-Dokumentation definiert nur `http.proxy`, und dieser eine Schlüssel deckt HTTP- und HTTPS-Remotes ab. Für einen einzelnen HTTPS-Host nutzen Sie `http.https://host.proxy`.

### Wie nutze ich einen SOCKS5-Proxy mit Git?

Setzen Sie `http.proxy` auf `socks5h://user:pass@host:port`; das `h` lässt den Proxy die Hostnamen auflösen. Das gilt für HTTPS-Remotes, während SSH-Remotes `ProxyCommand` mit einem SOCKS-fähigen Hilfsprogramm wie `nc -X 5` brauchen.

### Nutzt Git die Proxy-Einstellungen von Windows?

Verlassen Sie sich nicht darauf. Die Git-Dokumentation nennt als Proxy-Quellen nur die eigenen `http.proxy`-Schlüssel und die Variablen rund um `https_proxy`. Setzen Sie `http.proxy` ausdrücklich und testen Sie mit `git ls-remote`.

### Warum ignoriert git clone über SSH meinen Proxy?

Weil `http.proxy` nur HTTP- und HTTPS-Remotes betrifft. SSH-Remotes brauchen eine Zeile `ProxyCommand` oder `ProxyJump` in `~/.ssh/config` oder in `core.sshCommand`; alternativ klonen Sie die HTTPS-URL desselben Repositorys.

## Fazit

Git bezieht seinen HTTPS-Proxy aus `http.proxy`, einmal mit `git config --global` gesetzt und mit `http.<url>.proxy` auf einen Host eingegrenzt; ein leerer Wert oder `NO_PROXY` nimmt interne Server aus, und die Konfiguration hat Vorrang vor `https_proxy`. Kodieren Sie das Passwort per Prozentkodierung, bevorzugen Sie `socks5h://` für SOCKS5, stellen Sie `http.proxyAuthMethod` auf `basic`, wenn der Handshake abbricht, und beheben Sie Zertifikatsfehler mit `http.sslCAInfo`, nicht durch Abschalten der Prüfung. SSH-Remotes brauchen `ProxyCommand` oder `ProxyJump`. Testen Sie jede Änderung mit `git ls-remote`, bevor Sie etwas Großes klonen.
