Använda Dev Proxy med Node.js program

Överblick
Mål: Konfigurera Node.js program att använda Dev Proxy
Tid: 10 minuter
Krav:Konfigurera Dev Proxy, Node.js program

Hur du dirigerar Node.js begäranden via Dev Proxy beror på din Node.js version och det bibliotek som du använder för att göra HTTP-begäranden. Senaste Node.js-versioner kan dirigera det inbyggda fetch API:et och modulerna http och https via en proxy som definierats i miljövariabler. För äldre Node.js versioner och för andra bibliotek konfigurerar du proxyn i koden eller använder global-agent paketet för att aktivera proxystöd med minimala kodändringar.

Oavsett vilken metod du använder måste Node.js lita på rotcertifikatet för Dev Proxy för att göra HTTPS-begäranden via Dev Proxy. Mer information finns i artikeln ”Lita på Dev Proxy-certifikatet”.

Lita på Dev Proxy-certifikatet

Node.js använder inte operativsystemets certifikatarkiv som standard, så det litar inte på Rotcertifikatet för Dev Proxy även efter att du har litat på det på datorn. I stället för att inaktivera certifikatverifiering lägger du till Dev Proxy-rotcertifikatet till de certifikat som Node.js litar på med hjälp av miljövariabeln NODE_EXTRA_CA_CERTS.

NODE_EXTRA_CA_CERTS kräver ett certifikat i PEM-format. När Dev Proxy körs hämtar du API-token med devproxy api token och laddar ned rotcertifikatet i PEM-format med hjälp av Dev Proxy API:et:

TOKEN=$(devproxy api token)
curl -H "Authorization: Bearer $TOKEN" -o dev-proxy-ca.pem "http://127.0.0.1:8897/proxy/rootCertificate?format=crt"

Om du använder PowerShell kör du:

$token = devproxy api token
Invoke-WebRequest -Headers @{ Authorization = "Bearer $token" } -OutFile dev-proxy-ca.pem -Uri "http://127.0.0.1:8897/proxy/rootCertificate?format=crt"

Peka sedan miljövariabeln NODE_EXTRA_CA_CERTS mot den nedladdade filen när du startar appen:

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node index.js

Node.js läser NODE_EXTRA_CA_CERTS bara när processen startar, så du kan inte ange den från koden. Varje Dev Proxy-installation använder sitt eget rotcertifikat. Om du återskapar certifikatet, till exempel med hjälp av devproxy cert remove och devproxy cert ensure, ladda ned det igen.

Inbyggd Node.js hämtnings-API

Från och med Node.js v24.0.0 och v22.21.0 kan det interna fetch API:et använda proxyn som definierats i HTTP_PROXYmiljövariablerna , HTTPS_PROXYoch NO_PROXY . Från och med Node.js v24.5.0 och v22.21.0 gäller samma sak för modulerna http och https . Node.js ignorerar dessa variabler om du inte aktiverar proxystöd genom att ange NODE_USE_ENV_PROXY-miljövariabeln till 1 eller genom att starta Node.js med flaggan --use-env-proxy.

Du behöver inte ändra koden för att använda Dev Proxy med det inbyggda fetch API:et:

(async () => {
  const result = await fetch('https://jsonplaceholder.typicode.com/posts');
  const jsonResult = await result.json();
  console.log(JSON.stringify(jsonResult, null, 2));
})();

När du startar appen aktiverar du proxystöd, anger Dev Proxy som proxy och litar på rotcertifikatet för Dev Proxy:

NODE_USE_ENV_PROXY=1 HTTPS_PROXY=http://127.0.0.1:8000 HTTP_PROXY=http://127.0.0.1:8000 NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node index.js

Du kan också använda --use-env-proxy flaggan i stället för NODE_USE_ENV_PROXY miljövariabeln:

HTTPS_PROXY=http://127.0.0.1:8000 HTTP_PROXY=http://127.0.0.1:8000 NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node --use-env-proxy index.js

Note

Inbyggt proxystöd är i aktiv utveckling i Node.js. Om du vill kontrollera om din Node.js version stöder den kör du node --version. Om du använder en äldre version använder du undici-paketet eller global-agent-paketet enligt beskrivningen i följande avsnitt.

Använd det inbyggda fetch-API:et med äldre Node.js-versioner

Om du använder en Node.js-version som inte stöder NODE_USE_ENV_PROXY, använder du EnvHttpProxyAgent från undici-paketet, som implementerar det inbyggda fetch-API:et i Node.js. EnvHttpProxyAgent läser proxyn från HTTP_PROXY, HTTPS_PROXY och NO_PROXY-miljövariablerna. Ange den som global dispatcher i början av din app:

import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
setGlobalDispatcher(new EnvHttpProxyAgent());

(async () => {
  const result = await fetch('https://jsonplaceholder.typicode.com/posts');
  const jsonResult = await result.json();
  console.log(JSON.stringify(jsonResult, null, 2));
})();

När du startar appen anger du Dev Proxy som proxy och litar på rotcertifikatet för Dev Proxy:

HTTPS_PROXY=http://127.0.0.1:8000 HTTP_PROXY=http://127.0.0.1:8000 NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node index.mjs

global-agent

global-agent är ett populärt bibliotek som tillhandahåller en global HTTP/HTTPS-agent för Node.js. Med den kan du ange proxyn med hjälp av miljövariabler. Fördelen med att använda global-agent är att du inte behöver ändra hur du utfärdar HTTP-begäranden i ditt program för att använda Dev Proxy.

Här är ett exempel på hur du kan använda global-agent i ett Node.js program som använder node-fetch:

import fetch from 'node-fetch';
import { bootstrap } from 'global-agent';
bootstrap();

(async () => {
  const result = await fetch('https://jsonplaceholder.typicode.com/posts');
  const jsonResult = await result.json();
  console.log(JSON.stringify(jsonResult, null, 2));
})();

Så här kan du använda global-agent med Node.js och standardmodulen https :

const https = require('https');
const globalAgent = require('global-agent');
globalAgent.bootstrap();

https.get('https://jsonplaceholder.typicode.com/posts', (resp) => {
  let data = '';
  resp.on('data', (d) => {
    data += d;
  });
  resp.on('end', () => {
    console.log(JSON.parse(data));
  });
  resp.on('error', (err) => {
    console.error(err);
  });
});

När du startar programmet anger du proxyn med GLOBAL_AGENT_HTTP_PROXY miljövariabeln och lita på rotcertifikatet för Dev Proxy.

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem GLOBAL_AGENT_HTTP_PROXY=http://127.0.0.1:8000 node global-node-fetch.mjs

node-fetch

node-fetch är ett populärt bibliotek som tillhandahåller en fetch implementering för Node.js. node-fetch har inte stöd för att ange proxyn med hjälp av miljövariabler. I stället måste du skapa en anpassad agent och skicka den till fetch metoden.

Här är ett exempel på hur du kan använda node-fetch med Dev Proxy genom att definiera en agent med hjälp av https-proxy-agent paketet.

const fetch = require('node-fetch');
const { HttpsProxyAgent } = require('https-proxy-agent');

(async () => {
  // Create a custom agent pointing to Dev Proxy
  const agent = new HttpsProxyAgent('http://127.0.0.1:8000');
  // Pass the agent to the fetch method
  const result = await fetch('https://jsonplaceholder.typicode.com/posts', { agent });
  const jsonResult = await result.json();
  console.log(JSON.stringify(jsonResult, null, 2));
})();

När du startar appen lita på rotcertifikatet för Dev Proxy:

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node index.js

Axios

Axios är ett annat populärt bibliotek för att göra HTTP-begäranden i Node.js. Med Axios kan du ange proxyn med hjälp av miljövariabler eller ange agenten direkt i begärandekonfigurationen.

Använda Axios och Dev Proxy med miljövariabler

När du använder Dev Proxy med Axios och anger proxyn med hjälp av miljövariabler behöver du inte ändra koden. Allt du behöver göra är att ange https_proxy miljövariabeln och Axios använder den för att göra begäranden.

import axios from 'axios';

(async () => {
  const result = await axios.get('https://jsonplaceholder.typicode.com/posts');
  const response = result.data;
  console.log(JSON.stringify(response, null, 2));
})();

https_proxy Ange miljövariabeln antingen globalt eller när du startar din app och lita på rotcertifikatet för Dev Proxy.

https_proxy=http://127.0.0.1:8000 NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node axios.mjs

Fick

node-fetchPå liknande sätt stöder Got inte att ange proxyn med hjälp av miljövariabler. I stället måste du skapa en anpassad agent och skicka den till begäran.

Här är ett exempel på hur du kan använda Got with Dev Proxy:

import got from 'got';
import { HttpsProxyAgent } from 'https-proxy-agent';

(async () => {
  // Create a custom agent pointing to Dev Proxy
  const agent = new HttpsProxyAgent('http://127.0.0.1:8000');
  const result = await got('https://jsonplaceholder.typicode.com/posts', {
    // Pass the agent to the request
    agent: {
      https: agent
    }
  }).json();
  console.log(JSON.stringify(result, null, 2));
})();

När du startar appen lita på rotcertifikatet för Dev Proxy:

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node got.mjs

SuperAgent

SuperAgent har inte stöd för att ange proxyn med hjälp av miljövariabler. Om du vill använda Dev Proxy med SuperAgent måste du installera superagent-proxy plugin-programmet och konfigurera proxyn proxy med hjälp av metoden .

const superagent = require('superagent');
require('superagent-proxy')(superagent);

(async () => {
  const result = await superagent
    .get('https://jsonplaceholder.typicode.com/posts')
    .proxy('http://127.0.0.1:8000');
  console.log(JSON.stringify(result.body, null, 2));
})();

När du startar appen lita på rotcertifikatet för Dev Proxy:

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node superagent.js

Kända problem

När du använder Dev Proxy med Node.js kan det uppstå följande problem.

UNABLE_TO_VERIFY_LEAF_SIGNATURE fel

När du använder Dev Proxy med Node.js får du ett fel som liknar:

/Users/user/my-app/node_modules/node-fetch/lib/index.js:1501
                        reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
                               ^
FetchError: request to https://jsonplaceholder.typicode.com/posts failed, reason: unable to verify the first certificate
    at ClientRequest.<anonymous> (/Users/user/my-app/node_modules/node-fetch/lib/index.js:1501:11)
    at ClientRequest.emit (node:events:518:28)
    at TLSSocket.socketErrorListener (node:_http_client:495:9)
    at TLSSocket.emit (node:events:518:28)
    at emitErrorNT (node:internal/streams/destroy:169:8)
    at emitErrorCloseNT (node:internal/streams/destroy:128:3)
    at process.processTicksAndRejections (node:internal/process/task_queues:82:21) {
  type: 'system',
  errno: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
  code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'
}

Det här felet innebär att Node.js inte litar på rotcertifikatet för Dev Proxy. Du kan åtgärda det här problemet genom att ladda ned rotcertifikatet för Dev Proxy och ange miljövariabeln NODE_EXTRA_CA_CERTS som sökvägen till den nedladdade filen när du startar appen. Mer information finns i certifikatet för Trust the Dev Proxy.

NODE_EXTRA_CA_CERTS=./dev-proxy-ca.pem node index.js

Varning

Undvik att ställa in NODE_TLS_REJECT_UNAUTHORIZED till 0 för att kringgå det här felet. Den inaktiverar certifikatverifiering för alla HTTPS-begäranden som appen gör.

Se även

  • Uppdaterades senast