Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Interaktion mit dem Gerät mithilfe von Appium
Sobald Sie [eine Fernzugriffssitzung erstellt](how-to-create-session.md) haben, steht das Gerät für Appium-Tests zur Verfügung. Während der gesamten Dauer der Fernzugriffssitzung können Sie auf dem Gerät so viele Appium-Sitzungen ausführen, wie Sie möchten, ohne Einschränkungen, welche Clients Sie verwenden. Sie können beispielsweise damit beginnen, einen Test mit Ihrem lokalen Appium-Code von Ihrer IDE aus auszuführen und dann zur Verwendung von Appium Inspector übergehen, um alle auftretenden Probleme zu beheben. Die Sitzung kann bis zu [150 Minuten](limits.md#service-limits) dauern. Wenn jedoch länger als 5 Minuten keine Aktivität stattfindet (entweder über die interaktive Konsole oder über den Appium-Endpunkt), wird die Sitzung unterbrochen.
## Verwenden von Apps zum Testen mit Ihrer Appium-Sitzung
Es gibt verschiedene Möglichkeiten, eine App zur Verwendung mit Ihrer Appium-Sitzung bereitzustellen:
+ Laden Sie eine App auf Device Farm hoch und installieren Sie sie in der Sitzung.
+ Geben Sie eine HTTPS-URL oder Amazon S3 S3-URI als `appium:app` Funktion an.
+ Referenzieren Sie eine bereits installierte App anhand ihres Paketnamens (`appium:appPackage`unter Android oder `appium:bundleId` iOS).
+ Testen Sie eine Web-App, indem Sie die `browserName` Funktion angeben (`Chrome`auf Android, `Safari` auf iOS).
Die standardmäßigen [Größenbeschränkungen für Apps](limits.md#file-limits) (4 GB) gelten für alle App-Quellen.
**Anmerkung**
Device Farm unterstützt die Übergabe eines lokalen Dateisystempfads `appium:app` während einer Fernzugriffssitzung nicht.
### Apps hochladen, installieren und verwenden
Gehen Sie folgendermaßen vor, um eine hochgeladene App mit Ihrer Appium-Sitzung zu verwenden:
1.
**Laden Sie Ihre App hoch und installieren Sie sie**
Es gibt zwei Möglichkeiten, eine App hochzuladen und auf dem zu testenden Gerät zu installieren:
+ Nehmen Sie den App-ARN in Ihre [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html)Anfrage auf. Die App wird beim Start der Sitzung automatisch auf dem Gerät installiert. Sie können auch eine Zusatz-App ARNs hinzufügen, die zusammen mit der primären App installiert wird.
+ Installieren Sie die App während einer aktiven Sitzung mithilfe der [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html)API oder indem Sie sie über die Device Farm Farm-Konsole hochladen. Auf diese Weise können Sie die zu testende App ändern, ohne eine neue Sitzung zu erstellen.
1.
**Verwenden Sie die installierte App**
Nach der Installation wird die App automatisch als `appium:app` Standardfunktion für alle nachfolgenden Appium-Sitzungen eingefügt. Wenn Sie zusätzliche Apps hinzugefügt haben, werden diese als `appium:otherApps` Funktion festgelegt.
Wenn Sie beispielsweise eine Fernzugriffssitzung `com.aws.devicefarm.sample` als Ihre App und `com.aws.devicefarm.other.sample` als eine Ihrer Hilfs-Apps erstellen, verfügt diese bei der Erstellung einer Appium-Sitzung über Funktionen, die den folgenden ähneln:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
...
}
}
}
```
Wenn Sie während der Sitzung eine neue App installieren, ersetzt diese die aktuelle `appium:app` Funktion. Wenn die zuvor installierte App einen eindeutigen Paketnamen hat, verbleibt sie auf dem Gerät und wird zur `appium:otherApps` Funktion hinzugefügt.
Wenn Sie die App beispielsweise zunächst `com.aws.devicefarm.sample` bei der Erstellung Ihrer Fernzugriffssitzung verwenden, dann aber `com.aws.devicefarm.other.sample` während der Sitzung installieren, verfügen Ihre Appium-Sitzungen über Funktionen, die den folgenden ähneln:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.other.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
...
}
}
}
```
**Anmerkung**
Weitere Informationen zum automatischen Hochladen von Apps als Teil Ihrer Fernzugriffssitzung finden Sie unter [Automatisieren](api-ref.md#upload-example) von App-Uploads.
### Verwenden einer HTTPS-URL
Sie können beim Erstellen einer Appium-Sitzung eine öffentlich zugängliche HTTPS-URL als `appium:app` gewünschte Funktion angeben. Die URL muss direkt auf eine herunterladbare App-Datei verweisen (z. B. eine `.apk` `.ipa` OR-Datei). Device Farm lädt die App von der angegebenen URL herunter und installiert sie auf dem zu testenden Gerät.
**Wichtig**
Es URLs werden nur HTTPS unterstützt. Reines HTTP URLs wird abgelehnt.
Mit der folgenden Appium-Sitzungserstellungsanforderung wird beispielsweise eine App von einer HTTPS-URL heruntergeladen:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "https://example.com/path/to/MyApp.apk"
}
]
}
}
```
### Verwenden einer Amazon S3 S3-URI
Sie können eine Amazon S3 S3-URI (z. B.`s3://my-bucket/path/to/MyApp.ipa`) als `appium:app` gewünschte Funktion angeben, wenn Sie eine Appium-Sitzung erstellen. Device Farm lädt die App vom angegebenen S3-Standort herunter und installiert sie auf dem zu testenden Gerät.
Um eine S3-URI verwenden zu können, müssen die folgenden Anforderungen erfüllt sein:
+ Die Fernzugriffssitzung muss von einem Projekt aus gestartet werden, für das eine [IAM-Ausführungsrolle](custom-test-environments-iam-roles.md) konfiguriert ist.
+ Die IAM-Ausführungsrolle muss eine maximale Sitzungsdauer von mindestens 150 Minuten haben, da die Rolle für die Dauer der RAS-Sitzung übernommen wird.
+ Die IAM-Ausführungsrolle muss berechtigt sein, das in `s3:GetObject` der URI angegebene S3-Objekt aufzurufen. Wir empfehlen außerdem, die `s3:HeadObject` Berechtigung für dasselbe Objekt zu erteilen, sodass Device Farm die Existenz des Objekts überprüfen kann, bevor der Download versucht wird.
Mit der folgenden Appium-Sitzungserstellungsanfrage wird beispielsweise eine App von einem S3-URI heruntergeladen:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "s3://my-test-bucket/apps/MyApp.ipa"
}
]
}
}
```
Im Folgenden finden Sie ein Beispiel für eine IAM-Berechtigungsrichtlinie, die den empfohlenen Zugriff für das Herunterladen einer App von Amazon S3 gewährt, einschließlich der optionalen `s3:HeadObject` Berechtigung. Weitere Informationen zur Konfiguration von IAM-Ausführungsrollen finden Sie unter. [Greifen Sie mithilfe einer IAM-Ausführungsrolle auf AWS-Ressourcen zu](custom-test-environments-iam-roles.md)
**Example**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:HeadObject"
],
"Resource": "arn:aws:s3:::my-test-bucket/apps/*"
}
]
}
```
### Verwenden einer bereits installierten App
Wenn die App, die Sie testen möchten, bereits auf dem Gerät installiert ist, können Sie sie direkt anhand ihres Paketnamens referenzieren, anstatt sie hochzuladen. Verwenden Sie die `appium:appActivity` Funktionen `appium:appPackage` und auf Android oder die `appium:bundleId` Funktion auf iOS.
Mit der folgenden Appium-Sitzungserstellungsanforderung wird beispielsweise eine bereits installierte Android-App gestartet:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:appPackage": "com.example.myapp",
"appium:appActivity": "com.example.myapp.MainActivity"
}
]
}
}
```
Verwenden Sie auf iOS `appium:bundleId` stattdessen:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:bundleId": "com.example.myapp"
}
]
}
}
```
### Eine Web-App testen
Um eine Web-App zu testen, geben Sie die `browserName` Funktion in Ihrer Appium-Sitzungserstellungsanfrage an. Verwenden Sie `Chrome` auf Android-Geräten oder `Safari` iOS-Geräten.
Mit der folgenden Anfrage wird Chrome beispielsweise auf einem Android-Gerät geöffnet:
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"browserName": "Chrome"
}
]
}
}
```
## Wie benutzt man den Appium-Endpunkt
Hier sind die Schritte für den Zugriff auf den Appium-Endpunkt der Sitzung über die Konsole AWS CLI, den und den. AWS SDKs Diese Schritte beinhalten die ersten Schritte mit der Ausführung von Tests unter Verwendung verschiedener Appium-Client-Testframeworks:
------
#### [ Console ]
1. Öffnen Sie die Seite Ihrer Fernzugriffssitzung in Ihrem Webbrowser:
1. Gehen Sie wie folgt vor, um eine Sitzung mit Appium Inspector auszuführen:
1. Klicken Sie auf die Schaltfläche **Appium-Sitzung einrichten**
1. Folgen Sie den Anweisungen auf der Seite zum Starten einer Sitzung mit Appium Inspector.
1. Gehen Sie wie folgt vor, um einen Appium-Test von Ihrer lokalen IDE aus auszuführen:
1. Klicken Sie auf das Symbol „Kopieren“ neben dem Text **Appium-Endpunkt-URL**
1. Fügen Sie diese URL an der Stelle, an der Sie derzeit Ihre Remote-Adresse oder Ihren Befehlsausführer angeben, in Ihren lokalen Appium-Code ein. Für sprachspezifische Beispiele klicken Sie bitte auf eine der Registerkarten in diesem Beispielfenster für die Sprache Ihrer Wahl.
------
#### [ AWS CLI ]
Stellen Sie zunächst sicher, dass Ihre AWS-CLI-Version vorhanden ist, up-to-date indem Sie [die neueste Version herunterladen und installieren](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Wichtig**
Das Appium-Endpunktfeld ist in älteren Versionen der AWS-CLI nicht verfügbar.
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
$ aws devicefarm get-remote-access-session \
--arn "arn:aws:devicefarm:us-west-2:123456789876:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
{
"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": "RUNNING",
"endpoints": {
"remoteDriverEndpoint": "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234...",
...
}
```
Sie können diese URL in Ihrem lokalen Appium-Code überall dort verwenden, wo Sie derzeit Ihre Remote-Adresse oder Ihren Befehlsausführer angeben. Für sprachspezifische Beispiele klicken Sie bitte auf eine der Registerkarten in diesem Beispielfenster für die Sprache Ihrer Wahl.
Ein Beispiel dafür, wie Sie direkt von der Befehlszeile aus mit dem Endpunkt interagieren können, finden Sie mit dem [Befehlszeilentool curl](https://curl.se/), um einen Endpunkt direkt aufzurufen: WebDriver
```
$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
{
"value":
{
"ready": true,
"message": "The server is ready to accept new connections",
"build":
{
"version": "2.5.1"
}
}
}
```
------
#### [ Python ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API-Aufruf benannt ist:
```
# To get the URL
import sys
import boto3
from botocore.exceptions import ClientError
def get_appium_endpoint() -> str:
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
device_farm_client = boto3.client("devicefarm", region_name="us-west-2")
try:
resp = device_farm_client.get_remote_access_session(arn=session_arn)
except ClientError as exc:
sys.exit(f"Failed to call Device Farm: {exc}")
remote_access_session = resp.get("remoteAccessSession", {})
endpoints = remote_access_session.get("endpoints", {})
endpoint = endpoints.get("remoteDriverEndpoint")
if not endpoint:
sys.exit("Device Farm response did not include endpoints.remoteDriverEndpoint")
return endpoint
# To use the URL
from appium import webdriver
from appium.options.android import UiAutomator2Options
opts = UiAutomator2Options()
driver = webdriver.Remote(get_appium_endpoint(), options=opts)
# ...
driver.quit()
```
------
#### [ Java ]
*Hinweis: Dieses Beispiel verwendet das AWS SDK for Java v2 und ist mit JDK-Versionen 11 und höher kompatibel.*
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
public class AppiumEndpointBuilder {
public static String getAppiumEndpoint() throws Exception {
String session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.credentialsProvider(DefaultCredentialsProvider.create())
.build()) {
GetRemoteAccessSessionResponse resp = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(session_arn).build()
);
String endpoint = resp.remoteAccessSession().endpoints().remoteDriverEndpoint();
if (endpoint == null || endpoint.isEmpty()) {
throw new IllegalStateException("remoteDriverEndpoint missing from response");
}
return endpoint;
}
}
}
// To use the URL
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URL;
public class ExampleTest {
public static void main(String[] args) throws Exception {
String endpoint = AppiumEndpointBuilder.getAppiumEndpoint();
UiAutomator2Options options = new UiAutomator2Options();
AndroidDriver driver = new AndroidDriver(new URL(endpoint), options);
try {
// ... your test ...
} finally {
driver.quit();
}
}
}
```
------
#### [ JavaScript ]
*Hinweis: Dieses Beispiel verwendet AWS SDK für JavaScript v3 und WebDriverIO v8\+ mit Node 18\+.*
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm";
export async function getAppiumEndpoint() {
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
const client = new DeviceFarmClient({ region: "us-west-2" });
const resp = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const endpoint = resp?.remoteAccessSession?.endpoints?.remoteDriverEndpoint;
if (!endpoint) throw new Error("remoteDriverEndpoint missing from response");
return endpoint;
}
// To use the URL with WebdriverIO
import { remote } from "webdriverio";
(async () => {
const endpoint = await getAppiumEndpoint();
const u = new URL(endpoint);
const driver = await remote({
protocol: u.protocol.replace(":", ""),
hostname: u.hostname,
port: u.port ? Number(u.port) : (u.protocol === "https:" ? 443 : 80),
path: u.pathname + u.search,
capabilities: {
platformName: "Android",
"appium:automationName": "UiAutomator2",
// ...other caps...
},
});
try {
// ... your test ...
} finally {
await driver.deleteSession();
}
})();
```
------
#### [ C\# ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
using System;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
public static class AppiumEndpointBuilder
{
public static async Task GetAppiumEndpointAsync()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
var config = new AmazonDeviceFarmConfig
{
RegionEndpoint = RegionEndpoint.USWest2
};
using var client = new AmazonDeviceFarmClient(config);
var resp = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var endpoint = resp?.RemoteAccessSession?.Endpoints?.RemoteDriverEndpoint;
if (string.IsNullOrWhiteSpace(endpoint))
throw new InvalidOperationException("RemoteDriverEndpoint missing from response");
return endpoint;
}
}
// To use the URL
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;
class Example
{
static async Task Main()
{
var endpoint = await AppiumEndpointBuilder.GetAppiumEndpointAsync();
var options = new AppiumOptions();
options.PlatformName = "Android";
options.AutomationName = "UiAutomator2";
using var driver = new AndroidDriver(new Uri(endpoint), options);
try
{
// ... your test ...
}
finally
{
driver.Quit();
}
}
}
```
------
#### [ Ruby ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# To get the URL
require 'aws-sdk-devicefarm'
def get_appium_endpoint
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
resp = client.get_remote_access_session(arn: session_arn)
endpoint = resp.remote_access_session.endpoints.remote_driver_endpoint
raise "remote_driver_endpoint missing from response" if endpoint.nil? || endpoint.empty?
endpoint
end
# To use the URL
require 'appium_lib_core'
endpoint = get_appium_endpoint
opts = {
server_url: endpoint,
capabilities: {
'platformName' => 'Android',
'appium:automationName' => 'UiAutomator2'
}
}
driver = Appium::Core.for(opts).start_driver
begin
# ... your test ...
ensure
driver.quit
end
```
------