> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Configuration des nœuds dédiés Solana : Guide complet de mise en route
> Guide complet pour configurer votre nœud dédié Solana avec le streaming gRPC, le plugin Yellowstone, et la configuration optimale pour les données blockchain.
## Comment commander des nœuds dédiés
Les nœuds dédiés peuvent être commandés directement depuis le [portail développeur](https://dashboard.helius.dev/dedicated-nodes) dans l'onglet Nœuds dédiés.
### Type de nœud
Le type de nœud que vous choisissez dépend de vos besoins. Puisque nous n'imposons aucune limite de débit, la performance de votre nœud dépendra entièrement de ses spécifications.
**Pour les applications de streaming gRPC** (cas d'utilisation principal), tout type de nœud fonctionnera bien.
**Important** : Bien que [`getProgramAccounts`](/docs/fr/api-reference/rpc/http/getprogramaccounts) soit pris en charge, les nœuds dédiés ne sont pas optimisés pour ces appels. Une utilisation intensive peut affecter la performance du nœud ou même provoquer sa défaillance. Utilisez votre plan partagé pour les requêtes `getProgramAccounts` car il dispose d'un indexeur personnalisé qui rend ces appels beaucoup plus rapides et fiables.
### Emplacement du nœud
Nous proposons des nœuds dans plusieurs régions : en Amérique du Nord (Pittsburgh, Newark, Salt Lake City, Los Angeles, Vancouver) ; en Europe (Dublin, Londres, Amsterdam, Francfort) ; et en Asie (Tokyo, Singapour) pour assurer la meilleure couverture géographique avec l'infrastructure mondiale de Solana.
Pour une latence optimale, choisissez un nœud proche de votre serveur. Votre nœud sera déployé dans les trois heures suivant le paiement.
### Client du nœud
Vous pouvez personnaliser votre nœud en sélectionnant le type de client — soit Agave, soit Jito Labs (fork de Agave avec une méthode supplémentaire `simulateBundle`)
Les nœuds dédiés **ne peuvent pas** envoyer des Jito Bundles par eux-mêmes. Pour envoyer des Jito Bundles, vous devez utiliser l'API Jito, qui gère l'emballage et l'envoi des bundles via le système de Jito.
### Plugin Geyser (Recommandé)
**Nous recommandons fortement d'ajouter le [Yellowstone](https://github.com/helius-labs/yellowstone-grpc) Geyser Plugin**, qui est le cas d'utilisation principal pour les nœuds dédiés. Il fournit un [streaming gRPC](/docs/fr/grpc) haute performance des slots, blocs, transactions, et mises à jour de compte.
**Bonne pratique** : Les nœuds dédiés sont optimisés pour le streaming gRPC. Utilisez votre plan partagé pour la soumission de transactions, les requêtes d'archives, et les opérations RPC complexes.
### Options de paiement
Vous pouvez payer en fiat ou en crypto (USDC). Une fois votre paiement effectué, votre nœud sera déployé dans les 3 heures.
Pour la facturation, les paiements en fiat recevront une réduction sur la facture du mois suivant pour le nombre de jours nécessaires à la mise en service du nœud. Pour les paiements en crypto, le cycle de facturation commence une fois le nœud livré.
### Démo
## Mise en route
Une fois que votre nœud dédié est configuré et prêt (statut : **Réussi**), vous pouvez commencer à travailler avec.
## Connexion à votre nœud dédié
### Streaming gRPC (Cas d'utilisation principal)
**Les nœuds dédiés sont optimisés pour le streaming gRPC via le plugin Yellowstone Geyser.** C'est le moyen principal et recommandé d'utiliser votre nœud dédié.
**Considérez LaserStream pour le streaming gRPC** : LaserStream offre une performance supérieure, une fiabilité, et des fonctionnalités avancées comme la relecture historique sur 24 heures pour le streaming gRPC. Il est recommandé pour 99% des cas d'utilisation de streaming. [Comparez LaserStream vs Nœuds Dédiés](/docs/fr/laserstream/laserstream-vs-dedicated-nodes) pour évaluer la meilleure solution pour vos besoins, ou [commencez avec LaserStream](https://dashboard.helius.dev/laserstream) depuis votre tableau de bord Helius.
### RPC de base et Websocket (Fonctionnalité limitée)
Chaque nœud dédié offre également une fonctionnalité RPC de base, mais avec des limitations. **Pour les applications en production, combinez les nœuds dédiés avec un plan partagé.**
Ici, nous utilisons Solana web3.js pour appeler [`getSlot`](/docs/fr/api-reference/rpc/http/getslot) en utilisant notre nœud dédié :
```javascript theme={"system"}
// Using @solana/web3.js
const { Connection } = require('@solana/web3.js');
const connection = new Connection('https://liveried-grazings-gxzjabdgqa-dedicated.helius-rpc.com?api-key=465964ff-f718-47d2-a51c-66ddcce332d7');
// Get the current slot
const getSlot = async () => {
const slot = await connection.getSlot();
console.log('Current slot:', slot);
};
getSlot();
```
Voici comment vous établiriez une connexion websocket native pour diffuser de nouveaux slots :
```javascript theme={"system"}
const Websocket = require('ws');
const ws = new Websocket('wss://liveried-grazings-gxzjabdgqa-dedicated.helius-rpc.com?api-key=465964ff-f718-47d2-a51c-66ddcce332d7 ');
ws.onopen = () => {
ws.send(JSON.stringify({
jsonrpc: '2.0',
id: 1,
method: 'slotSubscribe'
}));
};
ws.onmessage = (event) => {
console.log(JSON.parse(event.data));
};
```
**Rappel** : Les exemples RPC ci-dessus sont pour une fonctionnalité de base uniquement. Limitations des nœuds dédiés:
* [`sendTransaction`](/docs/fr/api-reference/rpc/http/sendtransaction) pris en charge mais non optimisé - la plupart des transactions n'aboutiront pas (utilisez votre plan partagé pour une soumission de transactions fiable)
* Pas de requêtes de données archivées (utilisez votre plan partagé)
* [`getProgramAccounts`](/docs/fr/api-reference/rpc/http/getprogramaccounts) pris en charge mais non optimisé - une utilisation intensive peut affecter la performance ou provoquer une défaillance du nœud (utilisez votre plan partagé pour la fiabilité)
**Cas d'utilisation principal** : Utilisez la configuration de streaming gRPC ci-dessous pour une performance optimale.
### Configurez votre Plugin Geyser
Pour commencer à utiliser le plugin Geyser, vous devez cloner le dépôt Yellowstone :
```shell theme={"system"}
git clone https://github.com/helius-labs/yellowstone-grpc.git
```
#### Utilisation de la CLI
```sh theme={"system"}
cd yellowstone-grpc/examples/rust/
cargo run --bin client -- -e "https://liveried-grazings-gxzjabdgqa-dedicated-lb.helius-rpc.com:2053" --x-token 42f03938-1daa-4162-a457-bb551ecaf590 subscribe --slots
```
Une fois terminé, vous devriez voir la sortie du terminal pour de nouveaux slots. N'oubliez pas de remplacer l'URL et le Token par les vôtres.
### Exemple en TypeScript
Cet exemple diffuse toutes les transactions Raydium en direct au format JSON :
```typescript theme={"system"}
import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";
import * as bs58 from 'bs58';
const processBuffers = (obj: any): any =>
!obj ? obj :
Buffer.isBuffer(obj) || obj instanceof Uint8Array ? bs58.encode(obj) :
Array.isArray(obj) ? obj.map(processBuffers) :
typeof obj === 'object' ? Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, processBuffers(v)])) :
obj;
const main = async () => {
const client = new Client("grpc_url",
"x_token",
{ "grpc.max_receive_message_length": 64 * 1024 * 1024 });
const stream = await client.subscribe();
const write = (req: SubscribeRequest) => new Promise((resolve, reject) =>
stream.write(req, (err) => err ? reject(err) : resolve()));
stream.on("data", (data) => {
try { console.log(JSON.stringify(processBuffers(data), null, 2)); }
catch (e) { console.error('Error:', e); }
});
await write({
slots: {},
accounts: {},
accountsDataSlice: [],
transactions: {
allRaydiumTxs: {
accountInclude: ["675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"],
accountExclude: [],
accountRequired: [],
}
},
blocks: {},
blocksMeta: {},
entry: {},
commitment: CommitmentLevel.PROCESSED,
});
setInterval(() => write({
ping: { id: 1 },
accounts: {},
accountsDataSlice: [],
transactions: {},
blocks: {},
blocksMeta: {},
entry: {},
slots: {},
}).catch(console.error), 30000);
await new Promise((resolve, reject) => {
stream.on("error", (e) => { console.error("Stream error:", e); reject(e); stream.end(); });
stream.on("end", resolve);
stream.on("close", resolve);
});
};
main().catch(console.error);
```
### Type de nœud
Le type de nœud que vous choisissez dépend de vos besoins. Puisque nous n'imposons aucune limite de débit, la performance de votre nœud dépendra entièrement de ses spécifications.
**Pour les applications de streaming gRPC** (cas d'utilisation principal), tout type de nœud fonctionnera bien.
### Emplacement du nœud
Nous proposons des nœuds dans plusieurs régions : en Amérique du Nord (Pittsburgh, Newark, Salt Lake City, Los Angeles, Vancouver) ; en Europe (Dublin, Londres, Amsterdam, Francfort) ; et en Asie (Tokyo, Singapour) pour assurer la meilleure couverture géographique avec l'infrastructure mondiale de Solana.
Pour une latence optimale, choisissez un nœud proche de votre serveur. Votre nœud sera déployé dans les trois heures suivant le paiement.
### Client du nœud
Vous pouvez personnaliser votre nœud en sélectionnant le type de client — soit Agave, soit Jito Labs (fork de Agave avec une méthode supplémentaire `simulateBundle`)
### Exemple en TypeScript
Cet exemple diffuse toutes les transactions Raydium en direct au format JSON :
```typescript theme={"system"}
import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";
import * as bs58 from 'bs58';
const processBuffers = (obj: any): any =>
!obj ? obj :
Buffer.isBuffer(obj) || obj instanceof Uint8Array ? bs58.encode(obj) :
Array.isArray(obj) ? obj.map(processBuffers) :
typeof obj === 'object' ? Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, processBuffers(v)])) :
obj;
const main = async () => {
const client = new Client("grpc_url",
"x_token",
{ "grpc.max_receive_message_length": 64 * 1024 * 1024 });
const stream = await client.subscribe();
const write = (req: SubscribeRequest) => new Promise