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.
# Acceso remoto en AWS Device Farm
El acceso remoto le permite deslizar el dedo por la pantalla, realizar gestos e interactuar con un dispositivo a través del navegador web en tiempo real, con el fin de probar la funcionalidad y reproducir los problemas de los clientes. Usted interactúa con un dispositivo concreto mediante la creación de una sesión de acceso remoto con ese dispositivo.
Una sesión en Device Farm es una interacción en tiempo real con un dispositivo físico real con un navegador web como host. Una sesión muestra el único dispositivo seleccionado al comenzar la sesión. Un usuario puede comenzar más de una sesión a la vez con el número total de dispositivos simultáneos limitado por el número de ranuras de dispositivos que tiene. Puede adquirir ranuras de dispositivos en función de la familia de dispositivos (dispositivos Android o iOS). Para obtener más información, consulte los [precios de Device Farm](https://aws.amazon.com/device-farm/pricing/).
En la actualidad, Device Farm ofrece un subconjunto de dispositivos para pruebas de acceso remoto. Continuamente estamos añadiendo nuevos dispositivos al grupo de dispositivos.
Device Farm captura video de cada sesión de acceso remoto y genera registros de la actividad que tiene lugar durante la sesión. Estos resultados incluyen toda la información que usted proporciona durante una sesión.
**nota**
Por motivos de seguridad, le recomendamos que evite proporcionar o escribir información confidencial como, por ejemplo, números de cuenta, información de inicio de sesión personal y otros detalles durante una sesión de acceso remoto. Si es posible, utilice alternativas desarrolladas específicamente para las pruebas, como las cuentas de prueba.
**Topics**
+ [
# Creación de una sesión de acceso remoto en AWS Device Farm
](how-to-create-session.md)
+ [
# Uso de una sesión de acceso remoto en AWS Device Farm
](how-to-use-session.md)
+ [
# Obtención de resultados de una sesión de acceso remoto en AWS Device Farm
](how-to-access-session-results.md)
# 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).
# Uso de una sesión de acceso remoto en AWS Device Farm
Para obtener información sobre la realización de pruebas interactivas de aplicaciones Android e iOS a través de sesiones de acceso remoto, consulte [Sesiones](sessions.md),
+ [Requisitos previos](#how-to-use-session-prerequisites)
+ [Uso de una sesión en la consola de Device Farm](#how-to-use-session-console)
+ [Siguientes pasos](#how-to-use-session-next-steps)
+ [Sugerencias y trucos](#how-to-use-session-tips)
## Requisitos previos
+ Crear una sesión. Siga las instrucciones de [Creación de una sesión](how-to-create-session.md) y, a continuación, vuelva a esta página.
## Uso de una sesión en la consola de Device Farm
En cuanto el dispositivo que ha solicitado para una sesión de acceso remoto esté disponible, la consola muestra la pantalla del dispositivo. La sesión tiene una longitud máxima de 150 minutos. El tiempo restante de la sesión aparece en el campo **Tiempo restante** junto al nombre del dispositivo.
### Instalación de una aplicación
Para instalar una aplicación en el dispositivo de la sesión, en **Instalar aplicaciones**, seleccione **Cargar** y, a continuación, seleccione el archivo .apk (Android) o el archivo .ipa (iOS) que desee instalar. Las aplicaciones que se ejecutan en una sesión de acceso remoto no requieren aprovisionamiento ni instrumentación de pruebas.
**nota**
Cuando carga una aplicación, a veces existe un retraso antes de que la aplicación esté disponible. Aparecerá un mensaje de confirmación para informarte si la aplicación se instaló correctamente o no.
### Control del dispositivo
Puede interactuar con el dispositivo que se muestra en la consola del mismo modo que haría con el dispositivo físico real. Para ello, utilice el ratón o un dispositivo equivalente para tocar y el teclado en pantalla del dispositivo. Para dispositivos Android, existen botones en **Controles de visualización** que funcionan como los botones **Inicio** y **Atrás** de un dispositivo Android. Para dispositivos iOS, existe un botón **Inicio** que funciona exactamente igual que el botón de inicio de un dispositivo iOS. También puede cambiar entre las aplicaciones que se ejecutan en el dispositivo seleccionando **Aplicaciones recientes**.
### Cambio entre los modos vertical y horizontal
También puede cambiar entre los modos vertical y horizontal para los dispositivos que utilice.
## Siguientes pasos
Device Farm continúa la sesión hasta que se para manualmente o se alcanza el límite de tiempo de 150 minutos. Para finalizar la sesión, seleccione **Detener sesión**. Una vez finalizada la sesión, podrá obtener acceso al video capturado y a los registros generados. Para obtener más información, consulte [Recuperación de los resultados de la sesión](how-to-access-session-results.md).
## Sugerencias y trucos
Es posible que experimente problemas de rendimiento con la sesión de acceso remoto en algunas AWS regiones. Esto se debe, en parte, a la latencia presente en algunas regiones. Si experimenta problemas de desempeño, dé una oportunidad a la sesión de acceso remoto para que se recupere antes de volver a interactuar con la aplicación.
# Obtención de resultados de una sesión de acceso remoto en AWS Device Farm
Para obtener información sobre sesiones, consulte [Sesiones](sessions.md).
+ [Requisitos previos](#how-to-access-session-results-prerequisites)
+ [Visualización de detalles de una sesión](#how-to-view-session-details)
+ [Descarga de registros o video de una sesión](#how-to-access-session-files)
## Requisitos previos
+ Complete una sesión. Siga las instrucciones de [Uso de una sesión de acceso remoto en AWS Device FarmUso de una sesión](how-to-use-session.md) y, a continuación, vuelva a esta página.
## Visualización de detalles de una sesión
Cuando una sesión de acceso remoto finaliza, la consola de Device Farm muestra una tabla que contiene detalles sobre la actividad que tuvo lugar durante la sesión. Para obtener más información, consulte [Análisis de información de registro](how-to-use-reports.md#how-to-use-reports-console-log).
Para volver a los detalles de una sesión en otro momento:
1. En el panel de navegación de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**.
1. Seleccione el proyecto que contiene la sesión.
1. Seleccione **Acceso remoto** y, a continuación, seleccione la sesión que desee revisar de la lista.
## Descarga de registros o video de una sesión
Cuando una sesión de acceso remoto finaliza, la consola de Device Farm proporciona acceso a una captura de video de la sesión junto con los registros de actividad. En los resultados de la sesión, seleccione la pestaña **Archivos** para obtener una lista de enlaces a los registros y al video de la sesión. Puede ver estos archivos en el navegador o guardarlos localmente.