Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Accès à distance dans AWS Device Farm
L'accès à distance vous permet de balayer, d'appuyer et d'interagir avec un appareil par le biais de votre navigateur Web en temps réel afin de tester les fonctionnalités et de reproduire les problèmes des clients. Vous interagissez avec un appareil spécifique en créant une session d'accès à distance avec celui-ci.
Une session dans Device Farm est une interaction en temps réel avec un appareil physique réel hébergé dans un navigateur Web. Une session affiche le seul appareil que vous sélectionnez lorsque vous démarrez la session. Un utilisateur peut démarrer plusieurs sessions à la fois, le nombre total d'appareils simultanés étant limité par le nombre d'emplacements d'appareils dont vous disposez. Vous pouvez acheter des emplacements d'appareils en fonction du type d'appareil (appareils Android ou iOS). Pour plus d'informations, consultez [Tarification de Device Farm](https://aws.amazon.com/device-farm/pricing/).
Device Farm propose actuellement un sous-ensemble d'appareils pour les tests d'accès à distance. De nouveaux appareils sont constamment ajoutés à ce groupe d'appareils.
Device Farm capture une vidéo de chaque session d'accès à distance et génère des journaux d'activité pendant la session. Ces résultats incluent toutes les informations que vous fournissez au cours d'une session.
**Note**
Pour des raisons de sécurité, nous vous recommandons d'éviter de fournir ou de saisir des informations sensibles, telles que des numéros de compte, des informations de connexion personnelles et autres détails, pendant une session d'accès à distance. Si possible, utilisez des alternatives développées spécifiquement pour les tests, telles que des comptes de test.
**Topics**
+ [Création d'une session d'accès à distance dans AWS Device Farm](how-to-create-session.md)
+ [Utilisation d'une session d'accès à distance dans AWS Device Farm](how-to-use-session.md)
+ [Récupération des résultats d'une session d'accès à distance dans AWS Device Farm](how-to-access-session-results.md)
# Création d'une session d'accès à distance dans AWS Device Farm
Pour plus d'informations sur les sessions d'accès à distance, consultez [Séances](sessions.md).
+ [Conditions préalables](#how-to-create-session-prerequisites)
+ [Création d'une session à distance](#how-to-create-remote-session)
+ [Étapes suivantes](#how-to-create-session-next-steps)
## Conditions préalables
+ Créez un projet dans Device Farm. Suivez les instructions de [Création d'un projet dans AWS Device Farm](how-to-create-project.md), puis revenez à cette page.
## Création d'une session à distance
------
#### [ Console ]
1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).
1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**.
1. Si vous avez déjà un projet, sélectionnez-le dans la liste. Dans le cas contraire, créez un projet en suivant les instructions de[Création d'un projet dans AWS Device Farm](how-to-create-project.md).
1. Dans l'onglet **Accès à distance**, choisissez **Créer une session d'accès à distance**.
1. Choisissez un appareil pour votre session. Vous pouvez choisir parmi la liste des appareils disponibles ou rechercher un appareil à l'aide de la barre de recherche en haut de la liste.
1. *(Facultatif)* Incluez une application et des applications auxiliaires dans le cadre de la session. Il peut s'agir d'applications récemment téléchargées ou d'applications précédemment téléchargées dans le cadre de ce projet au cours des 30 derniers jours (après 30 jours, les téléchargements d'applications [expireront](data-protection.md#data-protection-retention)).
1. Dans **Session name (Nom de session)**, entrez le nom de la session.
1. Choisissez **Confirm and start session (Confirmer et démarrer la session)**.
------
#### [ AWS CLI ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
Tout d'abord, vérifiez que votre version de l'AWS CLI est up-to-date correcte en [téléchargeant et en installant la dernière version](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Important**
Certaines commandes mentionnées dans ce document ne sont pas disponibles dans les anciennes versions de l'AWS CLI.
Ensuite, vous pouvez déterminer sur quel appareil vous souhaitez effectuer le test :
```
$ aws devicefarm list-devices
```
Cela affichera des résultats tels que les suivants :
```
{
"devices":
[
{
"arn": "arn:aws:devicefarm:us-west-2::device:DE5BD47FF3BD42C3A14BF7A6EFB1BFE7",
"name": "Google Pixel 8",
"remoteAccessEnabled": true,
"availability": "HIGHLY_AVAILABLE"
...
},
...
]
}
```
Vous pouvez ensuite créer votre session d'accès à distance avec l'ARN de l'appareil de votre choix :
```
$ aws devicefarm create-remote-access-session \
--project-arn arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef \
--device-arn arn:aws:devicefarm:us-west-2::device:DE5BD47FF3BD42C3A14BF7A6EFB1BFE7 \
--app-arn arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef \
--configuration '{
"auxiliaryApps": [
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
]
}'
```
Cela affichera des résultats tels que les suivants :
```
{
"remoteAccessSession": {
"arn": "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000",
"name": "Google Pixel 8",
"status": "PENDING",
...
}
```
Maintenant, éventuellement, nous pouvons interroger et attendre que la session soit prête :
```
$ POLL_INTERVAL=3
TIMEOUT=600
DEADLINE=$(( $(date +%s) + TIMEOUT ))
while [[ "$(date +%s)" -lt "$DEADLINE" ]]; do
STATUS=$(aws devicefarm get-remote-access-session \
--arn "$DEVICE_FARM_SESSION_ARN" \
--query 'remoteAccessSession.status' \
--output text)
case "$STATUS" in
RUNNING)
echo "Session is ready with status: $STATUS"
break
;;
STOPPING|COMPLETED)
echo "Session ended early with status: $STATUS"
exit 1
;;
esac
done
```
------
#### [ Python ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
Cet exemple trouve d'abord n'importe quel appareil Google Pixel disponible sur Device Farm, puis crée une session d'accès à distance avec celui-ci et attend que la session soit en cours.
```
import random
import time
import boto3
client = boto3.client("devicefarm", region_name="us-west-2")
# 1) Gather all matching devices via paginated ListDevices with filters
filters = [
{"attribute": "MODEL", "operator": "CONTAINS", "values": ["Pixel"]},
{"attribute": "AVAILABILITY", "operator": "EQUALS", "values": ["AVAILABLE"]},
]
matching_arns = []
next_token = None
while True:
args = {"filters": filters}
if next_token:
args["nextToken"] = next_token
page = client.list_devices(**args)
for d in page.get("devices", []):
matching_arns.append(d["arn"])
next_token = page.get("nextToken")
if not next_token:
break
if not matching_arns:
raise RuntimeError("No available Google Pixel device found.")
# Randomly select one device from the full matching set
device_arn = random.choice(matching_arns)
print("Selected device ARN:", device_arn)
# 2) Create remote access session and wait until RUNNING
resp = client.create_remote_access_session(
projectArn="arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
deviceArn=device_arn,
appArn="arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", # optional
configuration={
"auxiliaryApps": [ # optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1",
]
},
)
session_arn = resp["remoteAccessSession"]["arn"]
print(f"Created Remote Access Session: {session_arn}")
poll_interval = 3
timeout = 600
deadline = time.time() + timeout
terminal_states = ["STOPPING", "COMPLETED"]
while True:
out = client.get_remote_access_session(arn=session_arn)
status = out["remoteAccessSession"]["status"]
print(f"Current status: {status}")
if status == "RUNNING":
print(f"Session is ready with status: {status}")
break
if status in terminal_states:
raise RuntimeError(f"Session ended early with status: {status}")
if time.time() >= deadline:
raise RuntimeError("Timed out waiting for session to be ready.")
time.sleep(poll_interval)
```
------
#### [ Java ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
*Remarque : cet exemple utilise le SDK AWS pour Java v2 et est compatible avec les versions 11 et supérieures du JDK.*
Cet exemple trouve d'abord n'importe quel appareil Google Pixel disponible sur Device Farm, puis crée une session d'accès à distance avec celui-ci et attend que la session soit en cours.
```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionConfiguration;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.CreateRemoteAccessSessionResponse;
import software.amazon.awssdk.services.devicefarm.model.Device;
import software.amazon.awssdk.services.devicefarm.model.DeviceFilter;
import software.amazon.awssdk.services.devicefarm.model.DeviceFilterAttribute;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
import software.amazon.awssdk.services.devicefarm.model.ListDevicesRequest;
import software.amazon.awssdk.services.devicefarm.model.ListDevicesResponse;
import software.amazon.awssdk.services.devicefarm.model.RuleOperator;
public class CreateRemoteAccessSession {
public static void main(String[] args) throws Exception {
DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.build();
String projectArn = "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef";
String appArn = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef";
String aux1 = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0";
String aux2 = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1";
// 1) Gather all matching devices via paginated ListDevices with filters
List filters = Arrays.asList(
DeviceFilter.builder()
.attribute(DeviceFilterAttribute.MODEL)
.operator(RuleOperator.CONTAINS)
.values("Pixel")
.build(),
DeviceFilter.builder()
.attribute(DeviceFilterAttribute.AVAILABILITY)
.operator(RuleOperator.EQUALS)
.values("AVAILABLE")
.build()
);
List matchingDeviceArns = new ArrayList<>();
String next = null;
do {
ListDevicesResponse page = client.listDevices(
ListDevicesRequest.builder().filters(filters).nextToken(next).build());
for (Device d : page.devices()) {
matchingDeviceArns.add(d.arn());
}
next = page.nextToken();
} while (next != null);
if (matchingDeviceArns.isEmpty()) {
throw new RuntimeException("No available Google Pixel device found.");
}
// Randomly select one device from the full matching set
String deviceArn = matchingDeviceArns.get(
ThreadLocalRandom.current().nextInt(matchingDeviceArns.size()));
System.out.println("Selected device ARN: " + deviceArn);
// 2) Create Remote Access session and wait until it is RUNNING
CreateRemoteAccessSessionConfiguration cfg = CreateRemoteAccessSessionConfiguration.builder()
.auxiliaryApps(Arrays.asList(aux1, aux2))
.build();
CreateRemoteAccessSessionResponse res = client.createRemoteAccessSession(
CreateRemoteAccessSessionRequest.builder()
.projectArn(projectArn)
.deviceArn(deviceArn)
.appArn(appArn) // optional
.configuration(cfg) // optional
.build());
String sessionArn = res.remoteAccessSession().arn();
System.out.println("Created Remote Access Session: " + sessionArn);
int pollIntervalMs = 3000;
long timeoutMs = 600_000L;
long deadline = System.currentTimeMillis() + timeoutMs;
while (true) {
GetRemoteAccessSessionResponse get = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(sessionArn).build());
String status = get.remoteAccessSession().statusAsString();
System.out.println("Current status: " + status);
if ("RUNNING".equals(status)) {
System.out.println("Session is ready with status: " + status);
break;
}
if ("STOPPING".equals(status) || "COMPLETED".equals(status)) {
throw new RuntimeException("Session ended early with status: " + status);
}
if (System.currentTimeMillis() >= deadline) {
throw new RuntimeException("Timed out waiting for session to be ready.");
}
Thread.sleep(pollIntervalMs);
}
}
}
```
------
#### [ JavaScript ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
*Remarque : cet exemple utilise le SDK AWS pour la JavaScript version 3.*
Cet exemple trouve d'abord n'importe quel appareil Google Pixel disponible sur Device Farm, puis crée une session d'accès à distance avec celui-ci et attend que la session soit en cours.
```
import {
DeviceFarmClient,
ListDevicesCommand,
CreateRemoteAccessSessionCommand,
GetRemoteAccessSessionCommand,
} from "@aws-sdk/client-device-farm";
const client = new DeviceFarmClient({ region: "us-west-2" });
// 1) Gather all matching devices via paginated ListDevices with filters
const filters = [
{ attribute: "MODEL", operator: "CONTAINS", values: ["Pixel"] },
{ attribute: "AVAILABILITY", operator: "EQUALS", values: ["AVAILABLE"] },
];
let nextToken;
const matching = [];
while (true) {
const page = await client.send(new ListDevicesCommand({ filters, nextToken }));
for (const d of page.devices ?? []) {
matching.push(d.arn);
}
nextToken = page.nextToken;
if (!nextToken) break;
}
if (matching.length === 0) {
throw new Error("No available Google Pixel device found.");
}
// Randomly select one device from the full matching set
const deviceArn = matching[Math.floor(Math.random() * matching.length)];
console.log("Selected device ARN:", deviceArn);
// 2) Create remote access session and wait until RUNNING
const out = await client.send(new CreateRemoteAccessSessionCommand({
projectArn: "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
deviceArn,
appArn: "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", // optional
configuration: {
auxiliaryApps: [ // optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1",
],
},
}));
const sessionArn = out.remoteAccessSession?.arn;
console.log("Created Remote Access Session:", sessionArn);
const pollIntervalMs = 3000;
const timeoutMs = 600000;
const deadline = Date.now() + timeoutMs;
while (true) {
const get = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const status = get.remoteAccessSession?.status;
console.log("Current status:", status);
if (status === "RUNNING") {
console.log("Session is ready with status:", status);
break;
}
if (status === "STOPPING" || status === "COMPLETED") {
throw new Error(`Session ended early with status: ${status}`);
}
if (Date.now() >= deadline) {
throw new Error("Timed out waiting for session to be ready.");
}
await new Promise((r) => setTimeout(r, pollIntervalMs));
}
```
------
#### [ C\$1 ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
Cet exemple trouve d'abord n'importe quel appareil Google Pixel disponible sur Device Farm, puis crée une session d'accès à distance avec celui-ci et attend que la session soit en cours.
```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
class Program
{
static async Task Main()
{
var client = new AmazonDeviceFarmClient(RegionEndpoint.USWest2);
// 1) Gather all matching devices via paginated ListDevices with filters
var filters = new List
{
new DeviceFilter { Attribute = DeviceAttribute.MODEL, Operator = RuleOperator.CONTAINS, Values = new List{ "Pixel" } },
new DeviceFilter { Attribute = DeviceAttribute.AVAILABILITY, Operator = RuleOperator.EQUALS, Values = new List{ "AVAILABLE" } },
};
var matchingArns = new List();
string nextToken = null;
do
{
var list = await client.ListDevicesAsync(new ListDevicesRequest
{
Filters = filters,
NextToken = nextToken
});
foreach (var d in list.Devices)
matchingArns.Add(d.Arn);
nextToken = list.NextToken;
}
while (nextToken != null);
if (matchingArns.Count == 0)
throw new Exception("No available Google Pixel device found.");
// Randomly select one device from the full matching set
var rnd = new Random();
var deviceArn = matchingArns[rnd.Next(matchingArns.Count)];
Console.WriteLine($"Selected device ARN: {deviceArn}");
// 2) Create remote access session and wait until RUNNING
var request = new CreateRemoteAccessSessionRequest
{
ProjectArn = "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
DeviceArn = deviceArn,
AppArn = "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", // optional
Configuration = new CreateRemoteAccessSessionConfiguration
{
AuxiliaryApps = new List
{
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
}
}
};
request.Configuration.AuxiliaryApps.RemoveAll(string.IsNullOrWhiteSpace);
var response = await client.CreateRemoteAccessSessionAsync(request);
var sessionArn = response.RemoteAccessSession.Arn;
Console.WriteLine($"Created Remote Access Session: {sessionArn}");
var pollIntervalMs = 3000;
var timeoutMs = 600000;
var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
while (true)
{
var get = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var status = get.RemoteAccessSession.Status.Value;
Console.WriteLine($"Current status: {status}");
if (status == "RUNNING")
{
Console.WriteLine($"Session is ready with status: {status}");
break;
}
if (status == "STOPPING" || status == "COMPLETED")
{
throw new Exception($"Session ended early with status: {status}");
}
if (DateTime.UtcNow >= deadline)
{
throw new TimeoutException("Timed out waiting for session to be ready.");
}
await Task.Delay(pollIntervalMs);
}
}
}
```
------
#### [ Ruby ]
*Remarque : ces instructions concernent uniquement la création d'une session d'accès à distance. Pour obtenir des instructions sur la façon de télécharger une application à utiliser pendant votre session, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).*
Cet exemple trouve d'abord n'importe quel appareil Google Pixel disponible sur Device Farm, puis crée une session d'accès à distance avec celui-ci et attend que la session soit en cours.
```
require 'aws-sdk-devicefarm'
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
# 1) Gather all matching devices via paginated ListDevices with filters
filters = [
{ attribute: 'MODEL', operator: 'CONTAINS', values: ['Pixel'] },
{ attribute: 'AVAILABILITY', operator: 'EQUALS', values: ['AVAILABLE'] },
]
matching_arns = []
next_token = nil
loop do
resp = client.list_devices(filters: filters, next_token: next_token)
resp.devices&.each { |d| matching_arns << d.arn }
next_token = resp.next_token
break unless next_token
end
abort "No available Google Pixel device found." if matching_arns.empty?
# Randomly select one device from the full matching set
device_arn = matching_arns.sample
puts "Selected device ARN: #{device_arn}"
# 2) Create remote access session and wait until RUNNING
resp = client.create_remote_access_session(
project_arn: "arn:aws:devicefarm:us-west-2:111122223333:project:12345678-1111-2222-333-456789abcdef",
device_arn: device_arn,
app_arn: "arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef", # optional
configuration: {
auxiliary_apps: [ # optional
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde0",
"arn:aws:devicefarm:us-west-2:111122223333:upload:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcde1"
].compact
}
)
session_arn = resp.remote_access_session.arn
puts "Created Remote Access Session: #{session_arn}"
poll_interval = 3
timeout = 600
deadline = Time.now + timeout
terminal = %w[STOPPING COMPLETED]
loop do
get = client.get_remote_access_session(arn: session_arn)
status = get.remote_access_session.status
puts "Current status: #{status}"
if status == 'RUNNING'
puts "Session is ready with status: #{status}"
break
end
abort "Session ended early with status: #{status}" if terminal.include?(status)
abort "Timed out waiting for session to be ready." if Time.now >= deadline
sleep poll_interval
end
```
------
## Étapes suivantes
Device Farm démarre la session dès que l'appareil et l'infrastructure demandés sont disponibles, généralement en quelques minutes. La boîte de dialogue **Device** Requested s'affiche jusqu'au démarrage de la session. Pour annuler la demande de session, choisissez **Cancel request (Annuler la demande)**.
Si l'appareil sélectionné est indisponible ou occupé, l'état de la session indique « **Appareil en attente** », ce qui indique que vous devrez peut-être attendre un certain temps avant que l'appareil ne soit disponible pour le test.
**Si votre compte a atteint sa limite de simultanéité pour les appareils publics avec ou sans compteur, le statut de la session indique « En attente de simultanéité ».** Pour les emplacements illimités, vous pouvez augmenter la simultanéité en [achetant davantage d'](how-to-purchase-device-slots.md)emplacements pour appareils. Pour les pay-as-you-go appareils équipés de compteurs, contactez AWS via un ticket d'assistance pour demander [une augmentation du quota de service](limits.md).
Lorsque la configuration de la session commence, elle affiche d'abord le statut **En cours**, puis le statut **Connexion** pendant que votre navigateur Web local tente d'ouvrir une connexion à distance avec l'appareil.
Après le démarrage d'une session, si vous fermez le navigateur ou l'onglet du navigateur sans arrêter la session, ou si la connexion entre le navigateur et Internet est perdue, la session reste active pendant cinq minutes. Device Farm met ensuite fin à la session. Votre compte est facturé pour le temps d'inactivité.
Une fois la session démarrée, vous pouvez interagir avec l'appareil dans le navigateur Web ou tester l'appareil à l'aide d'[Appium](appium-endpoint.md).
# Utilisation d'une session d'accès à distance dans AWS Device Farm
Pour de plus amples informations sur l'exécution des tests interactifs sur des applications Android et iOS grâce à des sessions d'accès à distance, veuillez consulter [Séances](sessions.md).
+ [Conditions préalables](#how-to-use-session-prerequisites)
+ [Utiliser une session dans la console Device Farm](#how-to-use-session-console)
+ [Étapes suivantes](#how-to-use-session-next-steps)
+ [Trucs et astuces](#how-to-use-session-tips)
## Conditions préalables
+ Créez une session. Suivez les instructions de [Création d'une session](how-to-create-session.md), puis revenez à cette page.
## Utiliser une session dans la console Device Farm
Dès que l'appareil que vous avez demandé pour une session d'accès à distance devient disponible, la console affiche son écran. La durée maximale de la session est de 150 minutes. Le temps restant dans la session apparaît dans le champ **Temps restant à côté** du nom de l'appareil.
### Installation d'une application
Pour installer une application sur l'appareil de session, dans **Installer des applications**, sélectionnez **Choisir un fichier**, puis choisissez le fichier .apk (Android) ou le fichier .ipa (iOS) que vous souhaitez installer. Les applications que vous exécutez lors d'une session d'accès à distance ne nécessitent aucune instrumentation de test, ni aucune mise en service.
**Note**
Lorsque vous chargez une application, l'application devient parfois disponible après un certain délai. Un message de confirmation s'affichera pour vous indiquer si l'application a été correctement installée ou non.
### Contrôle de l'appareil
Vous pouvez interagir avec l'appareil affiché dans la console comme vous le feriez avec l'appareil physique réel, en utilisant votre souris ou tout autre appareil équivalent pour la fonction tactile et le clavier à l'écran de l'appareil. Pour les appareils Android, il y a des boutons **View controls (Commandes d'affichage)** qui fonctionnent de la même manière que les boutons **Accueil** et **Retour** sur un appareil Android. Pour les appareils iOS, il existe un bouton **Home (Accueil)** qui fonctionne comme le bouton d'accueil sur un appareil iOS. Vous pouvez également basculer entre les applications exécutées sur l'appareil en choisissant **Recent Apps**.
### Basculer entre le mode portrait et le mode paysage
Vous pouvez également passer du mode portrait (vertical) au mode paysage (horizontal) pour les appareils que vous utilisez.
## Étapes suivantes
Device Farm poursuit la session jusqu'à ce que vous l'arrêtiez manuellement ou que le délai de 150 minutes soit atteint. Pour terminer la session, choisissez **Arrêter la session**. Lorsque la session s'arrête, vous pouvez accéder à la vidéo qui a été capturée et aux journaux qui ont été générés. Pour de plus amples informations, veuillez consulter [Récupération des résultats de session](how-to-access-session-results.md).
## Trucs et astuces
Vous pouvez rencontrer des problèmes de performances lors de la session d'accès à distance dans certaines AWS régions. Cela est dû en partie à la latence dans certaines régions. Si vous rencontrez des problèmes de performances, laissez à la session d'accès à distance la possibilité de rattraper son retard avant d'interagir à nouveau avec l'application.
# Récupération des résultats d'une session d'accès à distance dans AWS Device Farm
Pour plus d'informations sur les sessions, consultez [Séances](sessions.md).
+ [Conditions préalables](#how-to-access-session-results-prerequisites)
+ [Afficher les détails de la session](#how-to-view-session-details)
+ [Téléchargement de vidéos ou de journaux de session](#how-to-access-session-files)
## Conditions préalables
+ Terminez une session. Suivez les instructions de [Utilisation d'une session d'accès à distance dans AWS Device FarmUtilisation d'une session](how-to-use-session.md), puis revenez à cette page.
## Afficher les détails de la session
Lorsqu'une session d'accès à distance se termine, la console Device Farm affiche un tableau contenant des détails sur l'activité pendant la session. Pour plus d'informations, consultez la section relative à l'[analyse des informations de journal](how-to-use-reports.md#how-to-use-reports-console-log).
Pour revenir ultérieurement aux informations d'une session :
1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**.
1. Choisissez le projet contenant la session.
1. Choisissez **Accès à distance**, puis sélectionnez la session que vous souhaitez consulter dans la liste.
## Téléchargement de vidéos ou de journaux de session
Lorsqu'une session d'accès à distance se termine, la console Device Farm permet d'accéder à une capture vidéo de la session et aux journaux d'activité. Dans les résultats de la session, choisissez l'onglet **Files (Fichiers)** pour obtenir une liste de liens vers les vidéos et les journaux de la session. Vous pouvez consulter ces fichiers dans le navigateur ou les enregistrer localement.