Get "localhost:8080/api": unsupported protocol scheme "localhost"
URL-ul dat clientului HTTP nu începe cu http:// sau https://. Fără schemă, Go interpretează "localhost:" ca schemă (sau găsește o schemă goală) și refuză cererea. Adaugă http:// în fața adresei.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Clientul HTTP din Go (http.Get, http.Post, client.Do) are nevoie de un URL complet, cu schemă: http://localhost:8080/api. Dacă scrii doar localhost:8080/api, parserul de URL vede localhost înainte de : și îl consideră schemă. Cum clientul știe doar http și https, întoarce Get "localhost:8080/api": unsupported protocol scheme "localhost".
Când adresa e doar o cale sau un nume (/api/produse, api.exemplu.ro/date), schema e goală și mesajul este unsupported protocol scheme "". Dacă adresa începe cu o adresă IP (127.0.0.1:8080/api), apare altă eroare: first path segment in URL cannot contain colon.
Aproape mereu, URL-ul vine dintr-o variabilă de mediu sau dintr-un fișier de configurare în care s-a scris doar host:port. Primul cuvânt din mesaj (Get, Post) arată metoda, iar între ghilimele vezi URL-ul exact folosit.
De ce apare: cauzele frecvente
1Adresă fără schemă
resp, err := http.Get("localhost:8080/api/produse")resp, err := http.Get("http://localhost:8080/api/produse")Cu http://, parserul știe ce e schema, ce e hostul și ce e calea.
2Doar calea, fără host
resp, err := http.Get("/api/produse")base := "http://localhost:8080"
resp, err := http.Get(base + "/api/produse")Clientul din Go nu are o adresă „curentă” ca browserul; are nevoie de URL-ul complet. Mesajul este unsupported protocol scheme "".
3Variabilă de mediu cu doar host:port
api := os.Getenv("API_ADDR") // "localhost:9000"
http.Get(api + "/status")api := os.Getenv("API_URL") // "http://localhost:9000"
u, err := url.Parse(api)
if err != nil || u.Scheme == "" {
log.Fatal("API_URL trebuie să înceapă cu http:// sau https://")
}Validează URL-urile din configurare la pornire, ca greșeala să apară imediat și cu un mesaj clar.
Repară eroarea, direct în pagină
Un client cere un salut de la un server de test pornit local, dar construiește adresa fără schemă și cererea eșuează cu Get "localhost:...": unsupported protocol scheme "localhost". Repară URL-ul ca programul să afișeze Răspuns: Salut!.
package main
import (
"fmt"
"io"
"log"
"net"
"net/http"
"net/http/httptest"
)
func main() {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Salut!")
}))
defer srv.Close()
port := srv.Listener.Addr().(*net.TCPAddr).Port
adresa := fmt.Sprintf("localhost:%d/salut", port)
resp, err := http.Get(adresa)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
corp, _ := io.ReadAll(resp.Body)
fmt.Println("Răspuns:", string(corp))
}Răspuns: Salut!
Indiciu
URL-ul trebuie să înceapă cu http://.
Reparația
package main
import (
"fmt"
"io"
"log"
"net"
"net/http"
"net/http/httptest"
)
func main() {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Salut!")
}))
defer srv.Close()
port := srv.Listener.Addr().(*net.TCPAddr).Port
adresa := fmt.Sprintf("http://localhost:%d/salut", port)
resp, err := http.Get(adresa)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
corp, _ := io.ReadAll(resp.Body)
fmt.Println("Răspuns:", string(corp))
}De ce merge
Fără http://, parserul de URL a luat localhost drept schemă, iar clientul HTTP știe doar http și https, așa că a refuzat cererea înainte să se conecteze. Cu schema adăugată, localhost devine hostul, portul serverului de test este folosit corect, iar handlerul răspunde cu Salut!.
Alte forme ale mesajului
Get "/api/produse": unsupported protocol scheme ""Post "api.exemplu.ro/comenzi": unsupported protocol scheme ""parse "127.0.0.1:8080/api": first path segment in URL cannot contain colon
Cum o eviți pe viitor
Ține în configurare URL-uri complete (API_URL=http://localhost:9000), nu doar host:port, și validează-le la pornire cu url.Parse (verifică Scheme și Host). Construiește căile cu url.JoinPath(base, "api", "produse") în loc să lipești șiruri. Când loghezi erorile de rețea, mesajul conține deja URL-ul, deci păstrează-l întreg.
Întrebări frecvente
Browserul acceptă localhost:8080, de ce Go nu?
Browserul completează automat http:// în bara de adrese. Clientul din Go nu ghicește nimic; folosește exact URL-ul primit.
Ce scheme acceptă http.Client?
Implicit http și https. Alte scheme (de exemplu file) trebuie înregistrate explicit cu Transport.RegisterProtocol.
Erori înrudite
dial tcp 127.0.0.1:8080: connect: connection refused Pe adresa și portul la care te conectezi nu ascultă niciun server. Verifică dacă serverul (aplicația, baza de date, containerul) chiar rulează, pe ce port ascultă și dacă te conectezi la hostul corect; în Docker, localhost din container nu e mașina ta. context deadline exceeded Operația a durat mai mult decât termenul (timeout) al contextului, iar contextul a fost anulat. Verifică dacă timeout-ul e realist pentru operație, dacă serviciul apelat răspunde lent și tratează eroarea (reîncercare, mesaj clar), în loc să oprești programul. listen tcp :8080: bind: address already in use Portul pe care vrei să pornești serverul e deja ocupat: de o instanță veche a programului tău, de alt server sau de un al doilea Listen pe același port în același program. Oprește procesul care ține portul (lsof -i :8080) sau alege alt port. Învață Go de la zero, cu exerciții la fiecare lecție
Curs Go: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
