Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Creación de una sesión de acceso remoto en AWS Device Farm
Para obtener información acerca de las sesiones de acceso remoto, consulte [Sesiones](sessions.md).
+ [Requisitos previos](#how-to-create-session-prerequisites)
+ [Crear una sesión remota](#how-to-create-remote-session)
+ [Siguientes pasos](#how-to-create-session-next-steps)
## Requisitos previos
+ Crear un proyecto en Device Farm. Siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md) y, a continuación, vuelva a esta página.
## Crear una sesión remota
------
#### [ Console ]
1. Inicie sesión en la consola de Device Farm en [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. En el panel de navegación de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**.
1. Si ya tiene un proyecto, selecciónelo de la lista. De lo contrario, para crear un proyecto, siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md).
1. En la pestaña **Acceso remoto**, seleccione **Crear sesión de acceso remoto**.
1. Elija un dispositivo para la sesión. Puede elegir en la lista de dispositivos disponibles o buscar un dispositivo mediante la barra de búsqueda en la parte superior de la lista.
1. *(Opcional)* Incluye una aplicación y aplicaciones auxiliares como parte de la sesión. Pueden ser aplicaciones recién cargadas o aplicaciones que se hayan cargado anteriormente en este proyecto en los últimos 30 días (después de 30 días, las cargas de aplicaciones [caducarán](data-protection.md#data-protection-retention)).
1. En **Nombre de sesión**, escriba un nombre para la sesión.
1. Seleccione **Confirmar e iniciar sesión**.
------
#### [ AWS CLI ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
En primer lugar, compruebe que su versión de AWS CLI esté up-to-date disponible [descargando e instalando la versión más reciente](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**importante**
Algunos comandos que se mencionan en este documento no están disponibles en las versiones anteriores de la AWS CLI.
A continuación, puede determinar en qué dispositivo desea realizar la prueba:
```
$ aws devicefarm list-devices
```
Esto mostrará un resultado como el siguiente:
```
{
"devices":
[
{
"arn": "arn:aws:devicefarm:us-west-2::device:DE5BD47FF3BD42C3A14BF7A6EFB1BFE7",
"name": "Google Pixel 8",
"remoteAccessEnabled": true,
"availability": "HIGHLY_AVAILABLE"
...
},
...
]
}
```
A continuación, puede crear su sesión de acceso remoto con el ARN del dispositivo que prefiera:
```
$ 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"
]
}'
```
Esto mostrará un resultado como el siguiente:
```
{
"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",
...
}
```
Ahora, opcionalmente, podemos sondear y esperar a que la sesión esté lista:
```
$ 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 ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
En este ejemplo, primero se busca cualquier dispositivo Google Pixel disponible en Device Farm, se crea una sesión de acceso remoto con él y se espera a que se ejecute la sesión.
```
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 ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
*Nota: en este ejemplo se utiliza el AWS SDK for Java v2 y es compatible con las versiones 11 y superiores de JDK.*
En este ejemplo, primero se busca cualquier dispositivo Google Pixel disponible en Device Farm, se crea una sesión de acceso remoto con él y se espera a que se ejecute la sesión.
```
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 ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
*Nota: en este ejemplo se utiliza AWS SDK para la JavaScript versión 3.*
En este ejemplo, primero se busca cualquier dispositivo Google Pixel disponible en Device Farm, se crea una sesión de acceso remoto con él y se espera a que se ejecute la sesión.
```
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 ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
En este ejemplo, primero se busca cualquier dispositivo Google Pixel disponible en Device Farm, se crea una sesión de acceso remoto con él y se espera a que se ejecute la sesión.
```
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 ]
*Nota: estas instrucciones se centran únicamente en la creación de una sesión de acceso remoto. Para obtener instrucciones sobre cómo cargar una aplicación para usarla durante la sesión, consulta cómo [automatizar la carga de aplicaciones](api-ref.md#upload-example).*
En este ejemplo, primero se busca cualquier dispositivo Google Pixel disponible en Device Farm, se crea una sesión de acceso remoto con él y se espera a que se ejecute la sesión.
```
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
```
------
## Siguientes pasos
Device Farm inicia la sesión en cuanto el dispositivo y la infraestructura solicitados estén disponibles, normalmente en unos minutos. Se muestra el cuadro de diálogo **Dispositivo solicitado** hasta que comienza la sesión. Para cancelar la solicitud de sesión, seleccione **Cancelar solicitud**.
Si el dispositivo seleccionado no está disponible o está ocupado, el estado de la sesión se muestra como **Dispositivo pendiente**, lo que indica que es posible que deba esperar algún tiempo antes de que el dispositivo esté disponible para realizar pruebas.
**Si tu cuenta ha alcanzado el límite de simultaneidad para dispositivos públicos con o sin contador, el estado de la sesión se muestra como pendiente de simultaneidad.** [En el caso de las ranuras para dispositivos sin contador, puedes aumentar la simultaneidad comprando más ranuras para dispositivos.](how-to-purchase-device-slots.md) En el caso de pay-as-you-go los dispositivos con contador, póngase en contacto con AWS a través de un ticket de soporte para solicitar [un aumento de la cuota de servicio](limits.md).
Cuando se inicia la configuración de la sesión, primero se muestra el estado En **curso** y, a continuación, el estado de **Conexión**, mientras el navegador web local intenta abrir una conexión remota con el dispositivo.
Una vez que se ha iniciado una sesión, si debe cerrar el navegador o una pestaña del navegador sin parar la sesión o si se pierde la conexión entre el navegador e Internet, la sesión permanecerá activa durante cinco minutos a partir de ese momento. Después de eso, Device Farm finaliza la sesión. El tiempo de inactividad se le cargará en su cuenta.
Una vez iniciada la sesión, puedes interactuar con el dispositivo en el navegador web o probar el dispositivo con [Appium](appium-endpoint.md).