> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/fr/api/event-hubs.md).

# Event Hubs

Configurez les Event Hubs de PowerShell Universal pour envoyer des commandes aux agents connectés, permettant l'exécution de scripts à distance dans des environnements de serveurs distribués.

{% hint style="info" %}
Les Event Hubs nécessitent une [licence](/powershell-universal/fr/licensing.md).
{% endhint %}

Les Event Hubs permettent d'envoyer des commandes PowerShell aux [PowerShell Universal Agents](/powershell-universal/fr/config/agent.md) connectés à partir du serveur PowerShell Universal. Les agents sont des services légers et multiplateformes qui peuvent s'exécuter sur des nœuds périphériques afin de permettre à PowerShell Universal d'émettre des commandes à leur intention.

Les Event Hubs fonctionnent soit selon une méthode de communication un à un du serveur vers l'agent, soit selon une méthode de communication en éventail un à plusieurs d'un event hub sur le serveur vers tous les agents connectés. Les agents n'exécutent pas de tâches directement et nécessitent l'utilisation de `Invoke-PSUCommand` à partir d'autres scripts exécutés au sein du serveur PowerShell Universal. Vous pouvez considérer les event hubs comme une façon d'effectuer de la communication à distance PowerShell sans utiliser le transport de communication à distance standard.

## À propos

PowerShell Universal exécute un serveur web doté d'un terminal websocket qui écoutera les connexions des agents. C'est ce qu'on appelle l'event hub. Vous pouvez configurer plusieurs event hubs par serveur PowerShell Universal avec des noms et des paramètres de sécurité différents. Une fois qu'un event hub est configuré sur le serveur, vous pouvez installer un agent sur n'importe quelle machine pouvant joindre PowerShell Universal via les ports HTTP standards.

L'agent nécessite une certaine configuration concernant l'endroit et la façon de se connecter au serveur. Une fois cela fait, l'agent peut être démarré pour établir la connexion websocket avec le serveur. Une fois la connexion établie, le serveur est alors informé du client connecté. Il sera enregistré dans le hub et des événements pourront ensuite être envoyés du serveur vers les agents.

Bien que vous ne puissiez pas planifier de tâches à exécuter directement sur les agents, vous pouvez exécuter des commandes sur les agents, au sein des tâches, des API et des applis dans le serveur.

## Exemple de base

À titre d'exemple, vous pourriez avoir un agent PowerShell Universal Linux exécuté dans votre centre de données américain. Le serveur PowerShell Universal, exécuté dans votre centre de données européen, a un event hub configuré nommé Linux. Sur le serveur, vous configureriez le hub en utilisant le fichier `eventHubs.ps1` ou dans la console d'administration.

```powershell
New-PSUEventHub -Name 'Linux'
```

Du côté de l'agent, vous configureriez ensuite un fichier `agent.ps1` pour indiquer à l'agent où il doit se connecter au serveur.

```json
{
    "Connections": [
        {
            "Url": "http://eu.mycompany.local",
            "Hub": "Linux"
        }
    ]
}
```

Une fois l'event hub créé et l'agent configuré, l'agent se connectera au serveur et pourra désormais accepter des commandes.

Au sein du serveur, vous pouvez créer un script qui s'exécute à l'intention de l'agent. Bien que le script lui-même ne s'exécute pas sur l'agent, vous pouvez utiliser l'applet de commande intégrée `Invoke-PSUCommand` pour le faire. Dans votre script, vous pourriez recueillir des informations sur l'hôte. Comme le paramètre `-Computer` est spécifié, cette commande sera exécutée directement sur l'agent et retournera le nom d'hôte au script exécuté dans le serveur.

```powershell
Invoke-PSUCommand -Command "hostname" -Computer "linuxhost-12" 
```

De plus, vous pouvez effectuer des actions sur l'ensemble du hub d'agents connectés. Si vous vouliez, par exemple, redémarrer tous les agents connectés, vous pourriez vous étendre à l'ensemble du hub.

```powershell
Invoke-PSUCommand -Command "reboot" -Hub "Linux"
```

## Créer un Event Hub

Pour créer un event hub, cliquez sur **Build > APIs > Event Hubs** et cliquez sur Create New Event Hub. Les Event Hubs sont nommés et peuvent choisir d'appliquer l'authentification et l'autorisation.

## Agent

Vous devrez installer et configurer le [PowerShell Universal Agent](/powershell-universal/fr/config/agent.md) pour utiliser les Event Hubs. L'agent est fourni sur plusieurs plateformes, sous forme de MSI installable sur Windows et sous forme d'image de conteneur Docker.

{% hint style="warning" %}
Si le journal de l'agent indique \`Event Hub not found\`, vérifiez d'abord que la valeur \`Hub\` dans \`agent.json\` correspond exactement à un Event Hub configuré sur l'instance PowerShell Universal cible. Dans les configurations courantes, cela signifie que l'agent a joint le serveur, mais que le hub nommé n'y existe pas encore ou que les noms ne correspondent pas.
{% endhint %}

## Envoyer des événements

À partir du serveur PowerShell Universal, vous pouvez envoyer des événements d'un hub vers les clients connectés en utilisant l'applet de commande `Send-PSUEvent` (`Invoke-PSUCommand` est un alias de `Send-PSUEvent`).

```powershell
Send-PSUEvent -Hub 'MyHub' -Data "Hello!"
```

Le paramètre `-Data` accepte un objet et sera sérialisé à l'aide de CLIXML puis envoyé au client. Les données seront désérialisées avant d'être transmises au bloc de script.

Vous pouvez également exécuter des commandes. Cela ne nécessite pas de définir un script sur le client de l'event hub. Vous pouvez aussi utiliser l'alias `Invoke-PSUCommand` pour imiter le comportement natif de PowerShell.

```powershell
Invoke-PSUCommand -Hub "MyHub" -Command "Start-Process" -Parameters @{
    FilePath = "Notepad"
}
```

### Inspecter les connexions actuelles

Utilisez `Get-PSUEventHubConnection -Active` pour voir les agents actuellement connectés.

```powershell
Get-PSUEventHubConnection -Hub 'eventHub' -Active
```

La commande non filtrée peut également inclure d'anciennes connexions déconnectées, donc `-Active` est la vue de dépannage la plus rapide lorsque vous voulez confirmer si un agent est présentement en ligne. Si vous devez cibler un client spécifique, utilisez le `ConnectionId` retourné avec `Send-PSUEvent`.

## Recevoir des données des clients

Cette fonctionnalité n'est disponible que lors de l'envoi de données à un client individuel, plutôt qu'à tous les clients connectés à un hub.

```powershell
$Connection = Get-PSUEventHubConnection | Where-Object UserName -eq 'Admin'
$Result = Send-PSUEvent -Hub 'Hub' -Data 'Say Hello!' -Connectionid $Connection.ConnectionId
Show-UDToast $Result
```

## Exemple : exécuter des scripts sur des machines distantes

{% hint style="info" %}
Cet exemple fournit une façon d'exécuter des scripts sur des machines distantes sans avoir à installer une autre instance de PowerShell Universal.
{% endhint %}

Cet exemple permet d'envoyer des scripts à des machines distantes et de les exécuter avec un script d'event hub générique.

D'abord, créez un event hub dans PowerShell Universal. Cet exemple n'utilise pas d'authentification.

Ensuite, installez le PowerShell Universal Agent sur la machine distante. Créez un fichier de configuration dans `%ProgramData%\PowerShellUniversal\agent.json`.

```json
{
    "Connections": [
        {
            "Url": "http://localhost:5000",
            "Hub": "eventHub",
            "ScriptPath": "script.ps1"
        }
    ]
}
```

Ensuite, créez un script d'assistance script.ps1 pour recevoir les données de l'event hub et traiter les demandes de PSU visant à invoquer des scripts. Il crée un nouveau fichier PS1 temporaire et utilise le `$EventData` transmis par le message de l'event hub avec le contenu et les paramètres du script.

```powershell
$TempFile = (New-TemporaryFile).FullName + ".ps1"
$EventData.Contents | Out-File -FilePath $TempFile
$Parameters = $EventData.Parameters
& $TempFile @Parameters
```

Dans PowerShell Universal, ajoutez un script que vous voulez exécuter sur la machine distante. Dans cet exemple, il démarre simplement un processus.

```powershell
param($Name)

Start-Process $Name
```

Enfin, ajoutez un autre script qui envoie l'événement au client. Cela pourrait aussi provenir d'une API ou d'une appli. Comme le script sur l'agent est générique, il exécutera simplement tout ce qui lui est transmis.

```powershell
param($TargetComputer, $ProcessName)
 
Send-PSUEvent -Computer $TargetComputer -Data @{
    Contents = Get-Content StartAProcess.ps1 -Raw
    Parameters = @{
        Name = $ProcessName
    }
}
```

À partir d'ici, vous pourriez même utiliser le script pour planifier des tâches à exécuter sur les machines distantes à l'aide de l'agent.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/fr/api/event-hubs.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
