proxymix
Outil

Vérificateur pour toute la liste : IP vivantes et anonymat

Un fichier Node.js vérifie toute la liste : lignes ip:port et lignes avec identifiant et mot de passe, HTTP et SOCKS5. Il range les proxys qui marchent dans un fichier, du plus rapide au plus lent, et affiche pour chacun l’IP de sortie et l’anonymat.

Ce que fait le vérificateur

proxy-probe.mjs prend une liste par lien ou dans un fichier et interroge une page judge à travers chaque ligne, c’est-à-dire un site qui renvoie les en-têtes de la requête reçue. La réponse donne trois faits sur le proxy : s’il marche, combien de temps a pris la requête et quelle IP le site a vue.

  • Formats de ligne : ip:port, host:port:login:password et login:password@host:port. Le préfixe http:// ou socks5:// fixe le protocole d’une ligne donnée.
  • Un mot de passe avec deux-points ou @ est bien interprété. Le script retire les doublons et ignore les lignes vides ou mal formées.
  • Le script vérifie 150 proxys à la fois et attend chacun 8 secondes au plus, donc mille lignes tiennent en une minute. Les paramètres changent ces deux nombres.
  • Chaque proxy qui marche reçoit une note d’anonymat : high, medium ou none.
  • Un proxy qui a répondu mais refusé l’identifiant ou le mot de passe va dans un compteur à part et non parmi les morts.
  • Les lignes qui marchent arrivent dans alive.txt telles quelles, de la plus rapide à la plus lente, et le fichier convient tout de suite à votre programme. Le paramètre --csv ajoute un rapport avec latence, IP de sortie et anonymat.

Il faut Node.js 18 ou plus récent. Aucun paquet externe, seulement des modules intégrés, tout le code tient dans un fichier. Votre liste ne part nulle part : le script se connecte uniquement aux proxys de la liste et à la page judge.

Télécharger et lancer en une commande

Lien direct vers le fichier :

Télécharger proxy-probe.mjshttps://proxymix.net/res/files/proxy-probe.mjs

Linux et macOS : la commande télécharge le fichier dans le dossier courant et lance la vérification aussitôt.

bash
wget -qO proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

La même chose avec curl, si le serveur n’a pas wget :

bash
curl -fsSLo proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

Sans enregistrer le fichier : curl transmet le script directement à Node, et les arguments viennent après le tiret.

bash
curl -fsSL https://proxymix.net/res/files/proxy-probe.mjs | node --input-type=module - list.txt

Remplacez list.txt par votre fichier ou par un lien vers la liste.

Façons de lancer

Forfait illimité : un lien vers la liste ip:port de l’espace client, sans .csv à la fin, car le vérificateur ne lit pas le tableau. Gardez --parallel sous le nombre de threads du forfait, sinon les connexions en trop seront refusées et de bonnes lignes finiront parmi les mortes.

bash
node proxy-probe.mjs "https://YOUR_LIST_LINK" --parallel 100

Offres au Go : un fichier de lignes host:port:login:password. Vérifiez les lignes SOCKS5 avec --kind socks5.

bash
node proxy-probe.mjs http-lines.txt
node proxy-probe.mjs socks-lines.txt --kind socks5

Proxys gratuits : une longue liste contient beaucoup de lignes mortes. Augmentez le parallélisme, réduisez l’attente et ne gardez du rapport que la note high.

bash
node proxy-probe.mjs free.txt --parallel 400 --wait 4 --csv report.csv
grep ',high$' report.csv | cut -d, -f1 > high.txt

Rapport pour un tableur : le CSV s’ouvre dans Excel et Google Sheets, avec les colonnes proxy, ms, exit_ip, anonymity.

bash
node proxy-probe.mjs list.txt --output ok.txt --csv report.csv

Votre propre page judge, si httpbin.org répond lentement ou reste fermé sur votre réseau. Toute adresse en http simple qui affiche les en-têtes de la requête convient.

bash
node proxy-probe.mjs list.txt --judge http://YOUR_SERVER/headers

Ce qu’affiche le script

La progression passe dans stderr sur une ligne qui se met à jour. Dans stdout, le script affiche les 15 proxys les plus rapides avec latence, IP de sortie et note, et sur la dernière ligne le nombre de proxys qui marchent. Voici la vérification de 38 proxys SOCKS5 gratuits, avec des adresses remplacées par des exemples :

sortie
$ node proxy-probe.mjs socks.txt --kind socks5 --csv report.csv
checking 38 proxys, 150 at a time, via httpbin.org
38/38 checked, 25 alive
198.51.100.17:1088      3497 ms  203.0.113.40    high
192.0.2.63:10461        3667 ms  198.51.100.86   high
203.0.113.109:13391     3844 ms  192.0.2.132     high
198.51.100.155:38182    3954 ms  198.51.100.155  high
203.0.113.178:80        4170 ms  203.0.113.178   high
192.0.2.201:16209       4240 ms  198.51.100.224  high
203.0.113.247:1080      4327 ms  203.0.113.247   high
192.0.2.20:1080         4340 ms  198.51.100.43   high
203.0.113.66:1026       4494 ms  192.0.2.89      high
203.0.113.66:1059       4572 ms  192.0.2.89      high
203.0.113.66:1045       4654 ms  192.0.2.89      high
203.0.113.66:1087       4666 ms  198.51.100.112  high
203.0.113.66:1099       4752 ms  198.51.100.112  high
203.0.113.135:10800     4786 ms  203.0.113.135   high
192.0.2.158:1080        4917 ms  192.0.2.158     high
25 of 38 alive, saved to alive.txt

Dans alive.txt, les lignes restent telles qu’elles étaient dans la liste. Le rapport CSV y ajoute les mesures :

fichiers
$ head -3 alive.txt
198.51.100.17:1088
192.0.2.63:10461
203.0.113.109:13391
$ head -4 report.csv
proxy,ms,exit_ip,anonymity
198.51.100.17:1088,3497,203.0.113.40,high
192.0.2.63:10461,3667,198.51.100.86,high
203.0.113.109:13391,3844,192.0.2.132,high

Installer Node.js sur un serveur neuf

Vérifiez d’abord la version avec node -v : v18 ou plus récent convient. Si Node manque ou date, installez-le pour votre système. Les commandes ci-dessous s’exécutent en root, un utilisateur ordinaire doit ajouter sudo devant apt, dnf et bash.

Debian 12 et Ubuntu 24.04 : le Node du dépôt standard convient.

bash
apt update && apt install -y nodejs
node -v

Ubuntu 20.04 et 22.04, Debian 11 et les systèmes dont le dépôt fournit un Node antérieur à 18 : la LTS actuelle du dépôt NodeSource.

bash
apt update && apt install -y curl
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
node -v

AlmaLinux, Rocky Linux et CentOS Stream :

bash
curl -fsSL https://rpm.nodesource.com/setup_22.x | bash -
dnf install -y nodejs
node -v

Lancement sous Windows

Installez Node.js LTS avec winget, intégré à Windows 10 et 11. Ouvrez ensuite une nouvelle fenêtre de terminal pour que le PATH se mette à jour.

PowerShell
winget install OpenJS.NodeJS.LTS

Télécharger le script et lancer la vérification dans PowerShell :

PowerShell
iwr https://proxymix.net/res/files/proxy-probe.mjs -OutFile proxy-probe.mjs -UseBasicParsing; node proxy-probe.mjs list.txt

Dans l’invite cmd, le curl intégré fonctionne :

cmd
curl -fsSLo proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs && node proxy-probe.mjs list.txt

Placez la liste dans le même dossier ou indiquez le chemin complet entre guillemets : node proxy-probe.mjs "C:\proxy\list.txt". Le fichier alive.txt apparaît dans le dossier d’où vous avez lancé la commande.

Vérification planifiée

Pour que votre programme prenne toujours des proxys vivants, lancez le vérificateur par minuteur et gardez le résultat dans un fichier fixe. Le script écrit la nouvelle liste dans un fresh.txt temporaire, puis une commande remplace alive.txt par ce fichier, ainsi le programme ne tombe jamais sur un fichier à moitié écrit. Si aucun proxy ne survit, le script se termine avec le code 1 et alive.txt garde la liste précédente.

Linux : placez le script dans un dossier à part et ouvrez le planificateur cron.

bash
mkdir -p /opt/probe && cd /opt/probe
wget -qO proxy-probe.mjs https://proxymix.net/res/files/proxy-probe.mjs
crontab -e

Ajoutez cette ligne : vérification toutes les 20 minutes, flock bloque une deuxième copie tant que la première tourne, et le journal va dans probe.log.

crontab
*/20 * * * * cd /opt/probe && flock -n probe.lock node proxy-probe.mjs "https://YOUR_LIST_LINK" --output fresh.txt >> probe.log 2>&1 && mv fresh.txt alive.txt

Windows : créez le dossier C:\probe et placez-y le script et un fichier run.cmd de deux lignes :

run.cmd
cd /d C:\probe
node proxy-probe.mjs "https://YOUR_LIST_LINK" --output fresh.txt >> probe.log 2>&1 && move /y fresh.txt alive.txt

Une seule commande crée la tâche toutes les 20 minutes :

cmd
schtasks /create /tn "proxy-probe" /tr "C:\probe\run.cmd" /sc minute /mo 20

Cette tâche fonctionne tant que vous restez connecté. Pour la lancer sans connexion, exécutez la commande en administrateur avec la clé /ru SYSTEM. Le signe % du lien de liste dans run.cmd s’écrit deux fois : %%.

Dans le programme, indiquez alive.txt comme fichier de proxys : /opt/probe/alive.txt sous Linux, C:\probe\alive.txt sous Windows. Si le programme sait relire le fichier par minuteur, activez-le, et les nouvelles lignes arriveront sans redémarrage.

Comment l’anonymat est noté

Avant la vérification, le script interroge la page judge directement et retient votre propre adresse. Il compare ensuite chaque réponse avec elle :

  • high : la page judge n’a vu ni votre adresse ni des en-têtes de proxy comme Via ou X-Forwarded-For ;
  • medium : votre adresse est cachée, mais le proxy s’est trahi par des en-têtes ;
  • none : votre vraie adresse est arrivée à la page judge, le proxy ne fait que transmettre le trafic.

Listes ProxyMix

Les lignes des offres au Go ressemblent à host:port:login:password : l’identifiant est déjà dans la ligne, et le vérificateur le transmet seul au proxy. Vérifiez chaque ligne de ces offres avec le protocole pour lequel elle a été créée.

Pour le vérificateur, prenez le lien du forfait sans .csv à la fin : aucun identifiant n’est nécessaire, et le vérificateur ne lit pas le tableau. L’accès est ouvert à l’IP ajoutée dans l’espace client, lancez donc le vérificateur depuis ce serveur. Un port prend HTTP, HTTPS, SOCKS4 et SOCKS5 : vérifiez avec le protocole qu’utilise votre programme.

Les lignes vérifiées de alive.txt se chargent directement dans ScrapeBox, Key Collector ou dans du code en Python.

Codes de sortie et messages

  • Code 0 : au moins un proxy marche. Code 1 : aucun ne marche, ou la liste ne contient aucune ligne de proxy.
  • Code 2 : paramètre incorrect, le script affiche l’aide.
  • « judge did not answer directly » : la page judge est indisponible ou bloquée pour votre machine. Choisissez-en une autre, sinon les proxys transparents passeront inaperçus.
  • « N of M lines with credentials were rejected » : ces proxys ont répondu mais refusé l’identifiant ou le mot de passe. Ils ne comptent pas parmi les morts. Vérifiez les accès dans le panneau du fournisseur.

Code du script

Le code est entièrement ouvert, lisez-le avant de le lancer sur votre serveur.

Afficher le code de proxy-probe.mjs
proxy-probe.mjs
import net from 'node:net';
import { readFile, writeFile } from 'node:fs/promises';

const settings = {
  parallel: 150,
  kind: 'http',
  wait: 8,
  judge: 'http://httpbin.org/get',
  output: 'alive.txt',
  csv: '',
};

const help = `usage: node proxy-probe.mjs <list-url-or-file> [options]

  list lines     ip:port, host:port:login:password or login:password@host:port;
                 start a line with socks5:// or http:// to set its protocol,
                 colons and @ signs inside a password are fine

  --parallel N   proxies checked at the same time (150)
  --kind K       http or socks5 (http)
  --wait S       seconds per proxy (8)
  --judge URL    plain http page that echoes request headers (http://httpbin.org/get)
  --output FILE  working proxies, fastest first (alive.txt)
  --csv FILE     extra report: proxy, ms, exit ip, anonymity`;

const args = process.argv.slice(2);
const source = args.find((a, i) => !a.startsWith('--') && !(args[i - 1] || '').startsWith('--'));
for (let i = 0; i < args.length; i++) {
  const name = args[i].startsWith('--') ? args[i].slice(2) : '';
  if (name === 'help') {
    console.log(help);
    process.exit(0);
  }
  if (name in settings) settings[name] = typeof settings[name] === 'number' ? Number(args[++i]) : args[++i];
}
if (!source || !['http', 'socks5'].includes(settings.kind) || !(settings.parallel > 0) || !(settings.wait > 0)) {
  console.error(help);
  process.exit(2);
}

const judge = new URL(settings.judge);
const judgePort = Number(judge.port || 80);
const leakHeaders = /\b(via|x-forwarded-for|forwarded|x-real-ip|client-ip|x-proxy-id)\b/i;
const ipv4 = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
const scrub = (text) => text.split(judge.hostname).join('');

const protoPrefix = /^(http|socks5h?):\/\/(.+)$/i;
const plausible = (host) => host === 'localhost' || /^[\w-]+(\.[\w-]+)+$/.test(host);
const validPort = (port) => /^\d{1,5}$/.test(port) && Number(port) > 0 && Number(port) < 65536;
const keyed = (item) => item.login !== undefined;
const label = (item) => (keyed(item) ? `${item.login}@${item.host}:${item.port}` : item.text);
const cell = (value) => (/[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value);
const rejected = () => Object.assign(new Error('credentials rejected'), { rejected: true });

function decode(raw) {
  const text = raw.trim();
  const tagged = text.match(protoPrefix);
  const body = tagged ? tagged[2].replace(/\/+$/, '') : text;
  const kind = tagged ? (tagged[1].toLowerCase() === 'http' ? 'http' : 'socks5') : '';
  const guesses = [];
  const colonForm = body.match(/^([^:@]+):(\d+):([^:]*):(.*)$/);
  if (colonForm) guesses.push({ host: colonForm[1], port: colonForm[2], login: colonForm[3], password: colonForm[4] });
  const atForm = body.match(/^([^:]*)(?::(.*))?@([^:@]+):(\d+)$/);
  if (atForm) guesses.push({ host: atForm[3], port: atForm[4], login: atForm[1], password: atForm[2] ?? '' });
  const usable = guesses.filter((g) => validPort(g.port));
  const best = usable.find((g) => plausible(g.host)) || usable[0];
  if (best) return { text, kind, ...best, port: Number(best.port) };
  if (tagged) {
    const bare = body.match(/^([^:@/]+):(\d+)$/);
    return bare && validPort(bare[2]) ? { text, kind, host: bare[1], port: Number(bare[2]) } : null;
  }
  const [host, port] = text.split(':');
  return host && /^\d+$/.test(port || '') ? { text: `${host}:${port}`, kind, host, port: Number(port) } : null;
}

async function loadLines(from) {
  const text = /^https?:\/\//.test(from) ? await (await fetch(from)).text() : await readFile(from, 'utf8');
  const seen = new Map();
  for (const raw of text.split(/\r?\n/)) {
    const item = decode(raw);
    if (item && !seen.has(item.text)) seen.set(item.text, item);
  }
  return [...seen.values()];
}

function talk(host, port) {
  const sock = net.connect({ host, port: Number(port) });
  let buffered = Buffer.alloc(0);
  let waiter = null;
  let ended = false;
  const wake = () => waiter && waiter();
  sock.on('data', (chunk) => { buffered = Buffer.concat([buffered, chunk]); wake(); });
  sock.on('end', () => { ended = true; wake(); });
  sock.on('error', () => { ended = true; wake(); });
  sock.on('close', () => { ended = true; wake(); });
  const take = (count) => new Promise((resolve, reject) => {
    const check = () => {
      if (buffered.length >= count) {
        const part = buffered.subarray(0, count);
        buffered = buffered.subarray(count);
        waiter = null;
        resolve(part);
      } else if (ended) {
        waiter = null;
        reject(new Error('closed'));
      }
    };
    waiter = check;
    check();
  });
  const rest = () => new Promise((resolve) => {
    const check = () => { if (ended) resolve(buffered.toString('latin1')); };
    waiter = check;
    check();
  });
  const ready = new Promise((resolve, reject) => {
    sock.once('connect', resolve);
    sock.once('error', reject);
    sock.once('close', () => reject(new Error('closed')));
  });
  return { sock, take, rest, ready };
}

async function socksOpen(link, item) {
  const withLogin = keyed(item);
  link.sock.write(Buffer.from([5, 1, withLogin ? 2 : 0]));
  const hello = await link.take(2);
  if (hello[0] !== 5) throw new Error('socks reply');
  if (withLogin && hello[1] === 255) throw rejected();
  if (withLogin && hello[1] === 2) {
    const user = Buffer.from(item.login);
    const secret = Buffer.from(item.password);
    if (!user.length || user.length > 255 || secret.length > 255) throw rejected();
    link.sock.write(Buffer.concat([Buffer.from([1, user.length]), user, Buffer.from([secret.length]), secret]));
    const ack = await link.take(2);
    if (ack[1] !== 0) throw rejected();
  } else if (hello[1] !== 0) {
    throw new Error('socks auth');
  }
  const name = Buffer.from(judge.hostname);
  link.sock.write(Buffer.concat([Buffer.from([5, 1, 0, 3, name.length]), name, Buffer.from([judgePort >> 8, judgePort & 255])]));
  const head = await link.take(4);
  if (head[1] !== 0) throw new Error('socks refused');
  const tail = head[3] === 1 ? 6 : head[3] === 4 ? 18 : (await link.take(1))[0] + 2;
  await link.take(tail);
}

async function probe(item) {
  const kind = item.kind || settings.kind;
  const started = performance.now();
  const link = talk(item.host, item.port);
  const timer = setTimeout(() => link.sock.destroy(), settings.wait * 1000);
  try {
    await link.ready;
    if (kind === 'socks5') await socksOpen(link, item);
    const target = kind === 'socks5' ? judge.pathname + judge.search : judge.href;
    const pass = kind === 'http' && keyed(item)
      ? `Proxy-Authorization: Basic ${Buffer.from(`${item.login}:${item.password}`).toString('base64')}\r\n`
      : '';
    link.sock.write(`GET ${target} HTTP/1.1\r\nHost: ${judge.host}\r\nUser-Agent: proxy-probe\r\nAccept: */*\r\n${pass}Connection: close\r\n\r\n`);
    const answer = await link.rest();
    const [head, ...bodyParts] = answer.split('\r\n\r\n');
    if (pass && /^HTTP\/1\.[01] 407/.test(head)) return { item, rejected: true };
    if (!/^HTTP\/1\.[01] 200/.test(head)) return null;
    const body = bodyParts.join('\r\n\r\n');
    return { item, ms: Math.round(performance.now() - started), body };
  } catch (err) {
    return err.rejected ? { item, rejected: true } : null;
  } finally {
    clearTimeout(timer);
    link.sock.destroy();
  }
}

function grade(body, myIp) {
  const text = scrub(body);
  if (myIp && text.includes(myIp)) return 'none';
  return leakHeaders.test(text) ? 'medium' : 'high';
}

let myIp = '';
try {
  myIp = (scrub(await (await fetch(judge.href, { signal: AbortSignal.timeout(10000) })).text()).match(ipv4) || [''])[0];
} catch {
  console.error('judge did not answer directly, anonymity will not detect transparent proxies');
}

const entries = await loadLines(source);
if (!entries.length) {
  console.error('no proxy lines found in', source);
  process.exit(1);
}
const withCredentials = entries.filter(keyed).length;
console.error(`checking ${entries.length} proxies${withCredentials ? ` (${withCredentials} with credentials)` : ''}, ${settings.parallel} at a time, via ${judge.host}`);

const alive = [];
const turnedAway = [];
let cursor = 0;
let done = 0;
let lastShown = 0;
const lane = async () => {
  while (cursor < entries.length) {
    const hit = await probe(entries[cursor++]);
    done++;
    if (hit && hit.rejected) {
      turnedAway.push(hit.item);
    } else if (hit) {
      const found = scrub(hit.body).match(ipv4) || [];
      const exit = found.find((ip) => ip !== myIp) || found[0] || '';
      alive.push({ entry: hit.item.text, shown: label(hit.item), ms: hit.ms, exit, level: grade(hit.body, myIp) });
    }
    if (done - lastShown >= Math.max(1, Math.ceil(entries.length / 20)) || done === entries.length) {
      lastShown = done;
      const denied = turnedAway.length ? `, ${turnedAway.length} rejected credentials` : '';
      process.stderr.write(`\r${done}/${entries.length} checked, ${alive.length} alive${denied} `);
    }
  }
};
await Promise.all(Array.from({ length: Math.min(settings.parallel, entries.length) }, lane));
process.stderr.write('\n');

alive.sort((a, b) => a.ms - b.ms);
await writeFile(settings.output, alive.map((p) => p.entry).join('\n') + (alive.length ? '\n' : ''));
if (settings.csv) {
  const rows = ['proxy,ms,exit_ip,anonymity', ...alive.map((p) => `${cell(p.entry)},${p.ms},${p.exit},${p.level}`)];
  await writeFile(settings.csv, rows.join('\n') + '\n');
}
const top = alive.slice(0, 15);
const width = Math.max(22, ...top.map((p) => p.shown.length));
for (const p of top) console.log(`${p.shown.padEnd(width)} ${String(p.ms).padStart(5)} ms  ${p.exit.padEnd(15)} ${p.level}`);
if (turnedAway.length) {
  console.log(`${turnedAway.length} of ${withCredentials} lines with credentials were rejected, first ${label(turnedAway[0])}: check the login and password`);
}
console.log(`${alive.length} of ${entries.length} alive, saved to ${settings.output}`);
process.exit(alive.length ? 0 : 1);

Et ensuite

Besoin de milliers de lignes qui ne meurent pas : composez une commande du type et du pays voulus. Les adresses gratuites par pays sont sur la page des proxys gratuits, et les guides de réglage montrent comment charger le fichier vérifié dans vos programmes.

Questions

Questions

Toutes les questions
Le vérificateur gère-t-il les proxys avec identifiant et mot de passe ?

Oui. Il interprète seul les lignes host:port:login:password et login:password@host:port. Les proxys HTTP reçoivent l’identifiant dans l’en-tête Proxy-Authorization, les SOCKS5 à l’étape d’autorisation. Le script affiche un identifiant refusé à part des lignes mortes.

Le vérificateur envoie-t-il ma liste quelque part ?

Non. Il contacte uniquement les proxys de votre liste et la page judge indiquée.

Pourquoi la page judge est-elle en http par défaut et non en https ?

En https, le proxy ne voit qu’un tunnel chiffré et ne peut pas ajouter d’en-têtes, donc les fuites resteraient invisibles. Le http simple montre ce que le proxy change.

Le vérificateur fonctionne-t-il sous Windows ?

Oui. Installez Node.js avec winget install OpenJS.NodeJS.LTS et lancez le script dans PowerShell ou cmd. Les commandes pour les deux interpréteurs et la tâche du planificateur figurent plus haut sur cette page.

À quelle fréquence vérifier une liste en planifié ?

Les proxys gratuits vivent peu, vérifiez-les toutes les 10 à 20 minutes. La liste d’un forfait illimité se vérifie une fois par heure. Les lignes des offres au Go mènent à une passerelle qui choisit seule l’adresse de sortie, une vérification après la création de la liste suffit.

Combien de lignes peut-on vérifier en une exécution ?

Le script n’a pas de limite, il garde sans peine des dizaines de milliers de lignes en mémoire. Le temps s’estime ainsi : divisez le nombre de lignes par --parallel et multipliez par --wait. Pour 10 000 lignes, 400 threads et 4 secondes d’attente, cela fait moins de deux minutes.

Prêt à essayer ?

Rechargez votre solde, créez une liste avec le type et le pays voulus et testez le pool sur votre site. 1 Go d’essai coûte dès $0,27 et le trafic reste valable trois mois.

Composer la commande