Comment puis-je déterminer l'adresse IP d'une demande donnée à partir d'un contrôleur? Par exemple (en express):

app.post('/get/ip/address', function (req, res) {
    // need access to IP address here
})

Dans votre requestobjet, il existe une propriété appelée connection, qui est un net.Socketobjet. L'objet net.Socket a une propriété remoteAddress, donc vous devriez pouvoir obtenir l'IP avec cet appel:

request.connection.remoteAddress

Voir la documentation pour http et net

ÉDITER

Comme le souligne @juand dans les commentaires, la bonne méthode pour obtenir l'adresse IP distante, si le serveur est derrière un proxy, est request.headers['x-forwarded-for']

var ip = req.headers['x-forwarded-for'] || 
     req.connection.remoteAddress || 
     req.socket.remoteAddress ||
     (req.connection.socket ? req.connection.socket.remoteAddress : null);

Notez que parfois, vous pouvez obtenir plusieurs adresses IP req.headers['x-forwarded-for']. De plus, un en- x-forwarded-fortête n'est pas toujours défini, ce qui peut générer une erreur.

Le format général du champ est:

x-forwarded-for: client, proxy1, proxy2, proxy3

où la valeur est une liste d'adresses IP séparées par des virgules + espaces, la plus à gauche étant le client d'origine et chaque proxy successif ayant transmis la demande en ajoutant l'adresse IP d'où il a reçu la demande. Dans cet exemple, la demande est passée par proxy1, proxy2puis proxy3. proxy3apparaît comme adresse distante de la demande.

C'est la solution suggérée par Arnav Gupta avec un correctif que Martin a suggéré ci-dessous dans les commentaires pour les cas où x-forwarded-forn'est pas défini:

var ip = (req.headers['x-forwarded-for'] || '').split(',').pop().trim() || 
         req.connection.remoteAddress || 
         req.socket.remoteAddress || 
         req.connection.socket.remoteAddress

Si vous utilisez express ...

req.ip

Je cherchais ça puis j'étais comme attendre, j'utilise express. Duh.

Vous pouvez rester SEC et simplement utiliser un noeud-ipware qui prend en charge IPv4 et IPv6 .

Installer:

npm install ipware

Dans votre app.js ou middleware:

var getIP = require('ipware')().get_ip;
app.use(function(req, res, next) {
    var ipInfo = getIP(req);
    console.log(ipInfo);
    // { clientIp: '127.0.0.1', clientIpRoutable: false }
    next();
});

Il tentera au mieux d'obtenir l'adresse IP de l'utilisateur ou retournera 127.0.0.1pour indiquer qu'il n'a pas pu déterminer l'adresse IP de l'utilisateur. Jetez un œil au fichier README pour les options avancées.

Vous pouvez utiliser request-ip pour récupérer l'adresse IP d'un utilisateur. Il gère un certain nombre de cas de bord différents, dont certains sont mentionnés dans les autres réponses.

Divulgation: j'ai créé ce module

Installer:

npm install request-ip

Dans votre application:

var requestIp = require('request-ip');

// inside middleware handler
var ipMiddleware = function(req, res, next) {
    var clientIp = requestIp.getClientIp(req); // on localhost > 127.0.0.1
    next();
};

J'espère que cela t'aides

request.headers['x-forwarded-for'] || request.connection.remoteAddress

Si l'en- x-forwarded-fortête est là, utilisez-le, sinon utilisez la .remoteAddresspropriété.

L'en- x-forwarded-fortête est ajouté aux demandes qui transitent par des équilibreurs de charge (ou d'autres types de proxy) configurés pour HTTP ou HTTPS (il est également possible d'ajouter cet en-tête aux demandes lors de l'équilibrage au niveau TCP à l' aide du protocole proxy ). En effet, la request.connection.remoteAddresspropriété contiendra l'adresse IP privée de l'équilibreur de charge plutôt que l'adresse IP publique du client. En utilisant une instruction OR , dans l'ordre ci-dessus, vous vérifiez l'existence d'un en- x-forwarded-fortête et l'utilisez s'il existe sinon utilisez le request.connection.remoteAddress.

La fonction suivante a tous les cas couverts aidera

var ip;
if (req.headers['x-forwarded-for']) {
    ip = req.headers['x-forwarded-for'].split(",")[0];
} else if (req.connection && req.connection.remoteAddress) {
    ip = req.connection.remoteAddress;
} else {
    ip = req.ip;
}console.log("client IP is *********************" + ip);

Il existe deux façons d'obtenir l'adresse IP:

1. let ip = req.ip

2. let ip = req.connection.remoteAddress;

Mais il y a un problème avec les approches ci-dessus.

Si vous exécutez votre application derrière Nginx ou tout autre proxy, chaque adresse IP unique le sera 127.0.0.1.

Ainsi, la meilleure solution pour obtenir l'adresse IP de l'utilisateur est: -

let ip = req.header('x-forwarded-for') || req.connection.remoteAddress;

Si vous utilisez la version express 3.x ou supérieure, vous pouvez utiliser le paramètre de proxy de confiance ( http://expressjs.com/api.html#trust.proxy.options.table ) et il parcourra la chaîne d'adresses dans l'en-tête x-forwarded-for et placez la dernière ip dans la chaîne que vous n'avez pas configurée comme proxy de confiance dans la propriété ip sur l'objet req.

Attention:

Ne vous contentez pas d'utiliser aveuglément ceci pour une limitation de débit importante:

let ip = request.headers['x-forwarded-for'].split(',')[0];

Il est très facile d'usurper:

curl --header "X-Forwarded-For: 1.2.3.4" "https://example.com"

Dans ce cas, la véritable adresse IP de l'utilisateur sera:

let ip = request.headers['x-forwarded-for'].split(',')[1];

Je suis surpris qu'aucune autre réponse n'ait mentionné cela.

Si vous obtenez plusieurs IP, cela fonctionne pour moi:

var ipaddress = (req.headers['x-forwarded-for'] || 
req.connection.remoteAddress || 
req.socket.remoteAddress || 
req.connection.socket.remoteAddress).split(",")[0];

IP simple à distance dans nodejs:

var ip = req.header('x-forwarded-for') || req.connection.remoteAddress;

Dans le nœud 10.14, derrière nginx, vous pouvez récupérer l'ip en le demandant via l'en-tête nginx comme ceci:

proxy_set_header X-Real-IP $remote_addr;

Puis dans votre app.js:

app.set('trust proxy', true);

Après cela, où que vous souhaitiez qu'il apparaisse:

var userIp = req.header('X-Real-IP') || req.connection.remoteAddress;

Je me rends compte que cela a été répondu à mort, mais voici une version ES6 moderne que j'ai écrite qui suit les normes eslint basées sur airbnb.

const getIpAddressFromRequest = (request) => {
  let ipAddr = request.connection.remoteAddress;

  if (request.headers && request.headers['x-forwarded-for']) {
    [ipAddr] = request.headers['x-forwarded-for'].split(',');
  }

  return ipAddr;
};

L'en-tête X-Forwarded-For peut contenir une liste d'IP proxy séparées par des virgules. La commande est client, proxy1, proxy2, ..., proxyN. Dans le monde réel, les gens implémentent des proxys qui peuvent fournir tout ce qu'ils veulent dans cet en-tête. Si vous êtes derrière un équilibreur de charge ou quelque chose, vous pouvez au moins faire confiance à la première adresse IP de la liste, au moins quel que soit le proxy qu'une demande a traversé.

Si vous utilisez Graphql-Yoga, vous pouvez utiliser la fonction suivante:

const getRequestIpAddress = (request) => {
    const requestIpAddress = request.request.headers['X-Forwarded-For'] || request.request.connection.remoteAddress
    if (!requestIpAddress) return null

    const ipv4 = new RegExp("(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)")

    const [ipAddress] = requestIpAddress.match(ipv4)

    return ipAddress
}

J'utilise express derrière nginx et

req.headers.origin

a fait l'affaire pour moi

Eu le même problème ... im aussi nouveau à javascript mais j'ai résolu cela avec req.connection.remoteAddress; cela m'a donné l'adresse IP (mais au format ipv6 :: ffff.192.168.0.101) puis .slice pour supprimer les 7 premiers chiffres.

var ip = req.connection.remoteAddress;

if (ip.length < 15) 
{   
   ip = ip;
}
else
{
   var nyIP = ip.slice(7);
   ip = nyIP;
}