To solve the problem of running Playwright tests reliably and efficiently on AWS, here are the detailed steps:
👉 Skip the hassle and get the ready to use 100% working script (Link in the comments section of the YouTube Video) (Latest test 31/05/2025)
First, ensure your development environment is set up with Node.js and Playwright. You’ll need to install Playwright using npm init playwright@latest. This sets up your basic project structure. Next, for AWS integration, you’ll want to leverage services like AWS Fargate for serverless container orchestration, AWS Lambda for serverless function execution though less ideal for long-running Playwright tests, or Amazon EC2 for more control over virtual machines. For containerization, create a Dockerfile that includes Playwright’s necessary dependencies like browser binaries. Build your Docker image: docker build -t playwright-aws .. Push this image to Amazon Elastic Container Registry ECR: aws ecr get-login-password --region your-region | docker login --username AWS --password-stdin your_aws_account_id.dkr.ecr.your-region.amazonaws.com. Then, docker tag playwright-aws:latest your_aws_account_id.dkr.ecr.your-region.amazonaws.com/playwright-aws:latest and docker push your_aws_account_id.dkr.ecr.your-region.amazonaws.com/playwright-aws:latest. Finally, deploy this container to AWS Fargate by defining an Amazon Elastic Container Service ECS task definition that points to your ECR image and specifies the necessary CPU, memory, and networking configurations. You can then run this task manually or trigger it via AWS Step Functions or AWS CodePipeline for automated testing workflows.
Leveraging AWS for Scalable Playwright Test Execution
Running end-to-end tests effectively is crucial for maintaining application quality, and Playwright has emerged as a powerful tool for this purpose.
However, local execution often hits limitations concerning scale, parallelization, and consistent environments.
This is where Amazon Web Services AWS steps in, offering a robust, scalable, and cost-efficient infrastructure to host and execute Playwright tests.
By offloading test execution to the cloud, development teams can achieve faster feedback cycles, more reliable results, and better resource utilization, transforming their continuous integration/continuous delivery CI/CD pipelines. Puppeteer on azure vm
This approach aligns with modern DevOps principles, promoting automation and efficiency.
Why AWS is Ideal for Playwright Testing
AWS provides a comprehensive suite of services that can be orchestrated to create a highly effective Playwright testing environment.
The inherent elasticity and global reach of AWS allow teams to run thousands of tests concurrently without managing underlying hardware.
This significantly reduces test execution time and allows for broader test coverage, identifying issues earlier in the development lifecycle.
- Scalability: AWS services like ECS Fargate and Lambda can automatically scale up or down based on demand, handling fluctuating test loads.
- Reliability: Redundant infrastructure across multiple availability zones ensures high uptime for your testing environment.
- Cost-Effectiveness: Pay-as-you-go models mean you only pay for the compute resources consumed during test execution, optimizing expenditure compared to maintaining dedicated on-premise hardware. For instance, a small Fargate task might cost less than a dollar per hour, making large-scale parallel testing economically viable.
- Global Reach: Run tests from various geographic regions to simulate real user conditions and validate performance across different locales.
- Integration with CI/CD: Seamless integration with AWS CodePipeline, CodeBuild, and Jenkins on EC2 instances facilitates automated test execution as part of your deployment workflow.
Key AWS Services for Playwright
Understanding the core AWS services that facilitate Playwright execution is fundamental. Scrape indeed
Each service offers unique advantages depending on the specific requirements of your testing strategy.
- Amazon Elastic Container Service ECS with Fargate: This is often the preferred choice for Playwright. Fargate removes the need to manage EC2 instances, letting you focus solely on your containerized application. Playwright, with its browser dependencies, is perfectly suited for containerization.
- Amazon EC2 Elastic Compute Cloud: Provides virtual servers instances with fine-grained control. Suitable for complex setups, dedicated test environments, or when specific operating system configurations are required. However, it demands more operational overhead for instance management.
- AWS Lambda: While intriguing for serverless execution, Lambda has limitations e.g., 15-minute execution timeout, 500MB deployment package size, 10GB ephemeral storage that make it challenging for full-fledged Playwright tests, especially those involving multiple browser launches or longer test suites. It might work for very short, isolated browser interactions.
- Amazon S3 Simple Storage Service: Ideal for storing test artifacts, screenshots, videos, and test reports. S3 offers high durability and availability, making it perfect for long-term storage and easy access for analysis.
- AWS CodeBuild: A fully managed continuous integration service that compiles source code, runs tests, and produces software packages. It can spin up a containerized environment, execute your Playwright tests, and integrates well with other AWS CI/CD services.
- AWS CodePipeline: Automates your release pipelines for fast and reliable updates. It can orchestrate CodeBuild to run tests at various stages of your deployment.
- AWS Secrets Manager/Parameter Store: Securely store sensitive information like API keys or user credentials required by your tests, preventing them from being hardcoded.
Containerizing Playwright Tests with Docker for AWS
The bedrock of running Playwright tests efficiently on AWS, especially with services like ECS Fargate or CodeBuild, is containerization.
Docker provides a standardized way to package your application and its dependencies, including browser binaries, ensuring that your tests run consistently across different environments, from your local machine to the cloud.
This eliminates the dreaded “it works on my machine” problem and streamlines deployment.
Building Your Docker Image for Playwright
A well-constructed Dockerfile is crucial. Puppeteer azure function
It defines the environment, installs dependencies, and sets up your test execution command.
# Use a base image that includes Node.js and common dependencies for Playwright
FROM mcr.microsoft.com/playwright/python:v1.39.0-jammy
# Set working directory
WORKDIR /app
# Copy package.json and package-lock.json to install dependencies
COPY package*.json ./
# Install project dependencies
RUN npm install
# Copy the rest of your application code
COPY . .
# Install Playwright browsers if not already part of the base image or specific version needed
# RUN npx playwright install --with-deps
# Command to run tests e.g., using npm script defined in package.json
# This will be overridden by the ECS Task Definition or CodeBuild spec
CMD
Key considerations for your Dockerfile:
- Base Image: Microsoft provides official Playwright Docker images e.g.,
mcr.microsoft.com/playwright/node:lts. These images come pre-installed with browsers and their dependencies, significantly simplifying your Dockerfile. Choose an image that matches your Node.js version. - Dependencies: Ensure all your project’s
npmor Yarn dependencies are installed within the container. - Browser Installation: If using a generic Node.js image, you’ll need
RUN npx playwright install --with-depsto install the necessary browser binaries and their system-level dependencies. The--with-depsflag is critical for ensuring all required OS libraries are present. - Working Directory: Define a clear
WORKDIRto organize your application files within the container. - CMD: While
CMDspecifies a default command, it’s often overridden by the ECS task definition or CodeBuild commands for specific test execution.
Pushing Your Docker Image to Amazon ECR
Once your Docker image is built, it needs to be stored in a registry that AWS services can access.
Amazon Elastic Container Registry ECR is AWS’s fully managed Docker container registry, offering high availability, security, and integration with ECS and CodeBuild. Puppeteer print
Steps to push to ECR:
-
Create an ECR Repository: Navigate to the ECR console in AWS and create a new repository e.g.,
playwright-tests. -
Authenticate Docker to ECR:
aws ecr get-login-password --region your-aws-region | docker login --username AWS --password-stdin your_aws_account_id.dkr.ecr.your-aws-region.amazonaws.comReplace
your-aws-regionandyour_aws_account_id. This command generates a temporary password for Docker to authenticate with ECR. -
Tag Your Docker Image: Puppeteer heroku
Docker tag playwright-tests:latest your_aws_account_id.dkr.ecr.your-aws-region.amazonaws.com/playwright-tests:latest
This tags your local image with the ECR repository URI.
-
Push the Image:
Docker push your_aws_account_id.dkr.ecr.your-aws-region.amazonaws.com/playwright-tests:latest
This uploads your Docker image to the ECR repository. Observations running headless browser
A typical Playwright image with browsers can be several hundreds of MBs e.g., 800MB – 1.2GB, so the push might take a few minutes depending on your internet speed.
By containerizing your tests and pushing them to ECR, you create a portable and consistent environment that can be easily deployed and executed across various AWS compute services, laying the groundwork for robust cloud-based testing.
Orchestrating Playwright Tests with AWS Fargate and ECS
AWS Fargate, a serverless compute engine for containers, is arguably the most efficient and recommended way to run Playwright tests at scale on AWS.
It allows you to run containers without having to provision, configure, or scale clusters of virtual machines.
This translates directly into less operational overhead and more focus on writing effective tests. Otp at bank
Designing Your ECS Task Definition for Playwright
An ECS Task Definition is a blueprint for your application.
It specifies the Docker image to use, CPU and memory allocation, networking configuration, and other parameters.
{
"family": "playwright-test-task",
"networkMode": "awsvpc",
"cpu": "1024",
"memory": "4096",
"requiresCompatibilities": ,
"executionRoleArn": "arn:aws:iam::your_aws_account_id:role/ecsTaskExecutionRole",
"taskRoleArn": "arn:aws:iam::your_aws_account_id:role/ecsTaskRole",
"containerDefinitions":
{
"name": "playwright-container",
"image": "your_aws_account_id.dkr.ecr.your-aws-region.amazonaws.com/playwright-tests:latest",
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/playwright-tests",
"awslogs-region": "your-aws-region",
"awslogs-stream-prefix": "ecs"
}
},
"environment":
{
"name": "BASE_URL",
"value": "https://your-application-url.com"
},
"name": "PLAYWRIGHT_WORKERS",
"value": "2"
,
"command":
}
}
Key parameters and considerations:
* `family`: A name for your task definition.
* `networkMode`: Always use `awsvpc` for Fargate tasks, as it provides a dedicated elastic network interface ENI for each task.
* `cpu` and `memory`: Crucial for Playwright. Playwright tests, especially with multiple workers and browser instances, can be resource-intensive.
* CPU: Measured in vCPUs. Common options: 256 .25 vCPU, 512 .5 vCPU, 1024 1 vCPU, 2048 2 vCPU, 4096 4 vCPU. For a typical Playwright suite, start with 1024 1 vCPU and scale up to 2048 2 vCPU or even 4096 4 vCPU for heavy parallelization.
* Memory: Measured in MB. Options range from 512MB to 30720MB 30GB. Playwright browsers consume significant memory. A minimum of 4096MB 4GB is recommended, often needing 8192MB 8GB or more depending on the number of parallel tests and browser types. Running 2 parallel Chromium instances might need 2GB RAM each, plus Node.js overhead.
* Recommendation: Begin with CPU: 1024, Memory: 4096 and monitor CloudWatch metrics. If tests are slow or failing due to OOM errors, incrementally increase resources.
* `requiresCompatibilities`: Must include `"FARGATE"`.
* IAM Roles `executionRoleArn`, `taskRoleArn`:
* `ecsTaskExecutionRole`: Grants permissions for the ECS agent to pull images from ECR and publish logs to CloudWatch. Requires `AmazonECSTaskExecutionRolePolicy`.
* `ecsTaskRole`: Grants permissions *to* your application the Playwright tests to interact with other AWS services e.g., S3 for artifact storage, Secrets Manager for credentials. This role will need policies like `AmazonS3FullAccess` for S3 if storing artifacts or `SecretsManagerReadWrite` if accessing secrets.
* `containerDefinitions`: An array defining the containers in your task.
* `name`: A unique name for your container.
* `image`: The ECR URI of your Playwright Docker image.
* `logConfiguration`: Essential for debugging. This sends container logs to AWS CloudWatch Logs, enabling you to view test output, errors, and Playwright traces.
* `environment`: Pass environment variables to your tests e.g., `BASE_URL`, `PLAYWRIGHT_WORKERS`.
* `command`: The command executed when the container starts. This overrides the `CMD` in your Dockerfile. Here, `npx playwright test --workers=2` runs your tests in parallel within the container. Adjust `--workers` based on your allocated CPU. A general rule of thumb is `workers = CPU_vCPUs - 1` or `CPU_vCPUs / 2` for very heavy tests.
# Running Playwright Tests as Fargate Tasks
You can run your Fargate tasks in several ways:
1. Manually via AWS CLI:
aws ecs run-task \
--cluster your-ecs-cluster-name \
--task-definition playwright-test-task \
--launch-type FARGATE \
--network-configuration "awsvpcConfiguration={subnets=,securityGroups=,assignPublicIp=ENABLED}" \
--region your-aws-region
* Ensure your subnets have internet access e.g., through a NAT Gateway or direct public IP assignment if less secure.
* Security groups should allow outbound access e.g., port 443 for HTTPS to your application.
2. Via AWS CodePipeline/CodeBuild: Integrate the `run-task` command or use CodeBuild's ECS deployment actions in your CI/CD pipeline. CodeBuild is particularly effective as it can build your Docker image, push it to ECR, and then trigger the Fargate task.
3. Via AWS Step Functions: For complex workflows e.g., running multiple test suites sequentially, parallelizing across different environments, Step Functions can orchestrate `RunTask` actions.
After execution, monitor your task in the ECS console and check the CloudWatch logs for the output of your Playwright tests.
If you've configured Playwright to output HTML reports or screenshots, these can be saved to an S3 bucket accessible by the `ecsTaskRole`.
Automating Playwright Test Execution with AWS CodeBuild
AWS CodeBuild is a fully managed continuous integration service that compiles source code, runs tests, and produces software packages.
It's a natural fit for automating Playwright test execution within your CI/CD pipeline, offering a robust, scalable, and cost-effective way to run your tests whenever code changes occur.
# Setting Up CodeBuild for Playwright
Integrating Playwright with CodeBuild involves defining a `buildspec.yml` file, which is a collection of build commands and settings that CodeBuild uses to run your build.
Example `buildspec.yml`:
```yaml
version: 0.2
phases:
install:
commands:
# Install Node.js and npm if not already present in the CodeBuild image
# CodeBuild images like "aws/codebuild/nodejs:18.11.0" come with Node.js
- echo "Installing dependencies..."
- npm install
# Install Playwright browsers with all dependencies
- npx playwright install --with-deps chromium firefox webkit
pre_build:
- echo "Running pre-build tasks..."
# You might set up environment variables or fetch secrets here
- echo "Tests will run against: $BASE_URL"
build:
- echo "Running Playwright tests..."
# Run Playwright tests with specified workers. Adjust based on CodeBuild's CPU/memory.
# For a buildspec, often you want to pass environment variables
- npm test -- --workers=4 # Assuming 'npm test' runs 'npx playwright test'
post_build:
- echo "Post-build tasks..."
# Generate Playwright HTML report and save to S3
- npx playwright show-report --output playwright-report
# Optionally upload test artifacts to S3
- aws s3 cp playwright-report/ s3://your-test-artifacts-bucket/playwright-reports/$CODEBUILD_BUILD_NUMBER/ --recursive --acl public-read
artifacts:
files:
- '/*' # Include all files generated by the build
base-directory: 'playwright-report' # Only upload the report directory
discard-paths: no
name: playwright-report-$CODEBUILD_BUILD_NUMBER
Key aspects of the `buildspec.yml`:
* `phases`: Defines the build lifecycle stages.
* `install`:
* `npm install`: Installs your project's Node.js dependencies.
* `npx playwright install --with-deps`: Crucial. This command installs the browser binaries Chromium, Firefox, WebKit and their necessary system-level dependencies within the CodeBuild environment. Without `--with-deps`, you'll likely encounter missing shared library errors.
* `pre_build`: Any setup before the main build, like setting environment variables or fetching dynamic data.
* `build`: The core execution phase where `npx playwright test` or `npm test` if configured runs.
* Parallelism `--workers`: The number of parallel workers Playwright uses. CodeBuild instances vary in CPU/memory.
* `build.general1.small` 1 vCPU, 3GB RAM: Use `--workers=1` or `--workers=2`.
* `build.general1.medium` 2 vCPU, 7GB RAM: Use `--workers=2` or `--workers=3`.
* `build.general1.large` 4 vCPU, 15GB RAM: Use `--workers=3` or `--workers=4`.
* Monitor CPU utilization and memory usage during builds to fine-tune this. Excessive workers can lead to slower execution or out-of-memory errors.
* `post_build`: Actions after tests complete.
* `npx playwright show-report --output playwright-report`: Generates the HTML report.
* `aws s3 cp`: Uploads the generated `playwright-report` directory to an S3 bucket. Ensure your CodeBuild service role has permissions to write to this S3 bucket.
* `artifacts`: Specifies files or directories to save after the build. Saving the Playwright HTML report to S3 makes it easily accessible for review.
# CodeBuild Project Configuration
When creating your CodeBuild project in the AWS console or via Infrastructure as Code IaC tools like CloudFormation/Terraform:
1. Source Provider: Connect to your source code repository e.g., GitHub, CodeCommit, S3.
2. Environment:
* Managed Image: Select a managed image. For Node.js and Playwright, choose a Node.js runtime e.g., `aws/codebuild/nodejs:18.11.0` or later.
* Environment Type: `Linux`
* Compute: Select the appropriate compute size based on your testing needs.
* `build.general1.small`: Good for quick, sequential tests.
* `build.general1.medium` or `build.general1.large`: Recommended for parallel Playwright execution.
* Service Role: CodeBuild creates a service role. Ensure it has:
* `CloudWatchLogsFullAccess` or specific policies for log streams.
* Permissions to access your source repository.
* `s3:PutObject` and `s3:GetObject` permissions for your artifact S3 bucket.
* Any other permissions needed e.g., `secretsmanager:GetSecretValue` if using Secrets Manager.
3. Buildspec: Specify `buildspec.yml` or define commands directly.
# Triggering CodeBuild
* Manually: Through the CodeBuild console.
* Via CodePipeline: The most common approach. Set up a CodePipeline that triggers a CodeBuild project whenever code is pushed to your repository. This ensures continuous testing.
* Webhooks: Configure a webhook in your source repository to trigger CodeBuild on specific events e.g., pull request merge.
CodeBuild provides detailed logs in CloudWatch, allowing you to debug test failures and monitor performance, making it a robust platform for automated Playwright testing.
Advanced Playwright and AWS Integrations
Beyond basic execution, integrating Playwright with other AWS services can unlock powerful capabilities for reporting, monitoring, and managing test data.
These advanced integrations elevate your testing strategy from mere execution to a comprehensive quality assurance ecosystem.
# Storing Test Artifacts in Amazon S3
Playwright can generate various artifacts: screenshots, videos, and HTML reports.
Storing these in Amazon S3 provides a durable, scalable, and cost-effective solution for long-term access and analysis.
* Configuration in `playwright.config.ts`:
```typescript
import { defineConfig } from '@playwright/test'.
export default defineConfig{
use: {
// Collect trace when retrying the failed test.
trace: 'on-first-retry',
screenshot: 'only-on-failure', // or 'on'
video: 'on-first-retry', // or 'on'
},
reporter:
,
,
outputDir: 'test-results', // Default for screenshots, videos, etc.
}.
* Uploading to S3 e.g., from CodeBuild or Fargate:
After test execution, use the AWS CLI to upload the relevant directories.
# Upload screenshots and videos
aws s3 cp test-results/ s3://your-test-artifacts-bucket/results/$CODEBUILD_BUILD_NUMBER/ --recursive --exclude "*.html"
# Upload the HTML report
aws s3 cp playwright-report/ s3://your-test-artifacts-bucket/reports/$CODEBUILD_BUILD_NUMBER/ --recursive --acl public-read
* `--recursive`: Ensures all subdirectories and files are uploaded.
* `--acl public-read`: Makes the HTML report publicly accessible if desired be cautious with sensitive data. Otherwise, restrict access via bucket policies or IAM roles.
* `$CODEBUILD_BUILD_NUMBER`: A dynamic environment variable from CodeBuild or similar for Fargate creates a unique folder for each test run, aiding organization.
# Centralized Logging and Monitoring with CloudWatch
CloudWatch is AWS's monitoring and observability service.
Integrating Playwright logs with CloudWatch provides real-time insights into test execution, errors, and performance.
* Fargate/ECS: As shown in the ECS task definition, configuring `logConfiguration` with `awslogs` automatically streams container logs to a specified CloudWatch Log Group.
* CodeBuild: CodeBuild projects automatically stream their console output to CloudWatch Logs.
* Analyzing Logs:
* In the CloudWatch console, navigate to Log Groups.
* Filter logs by keywords e.g., "FAIL", "Error", "Playwright".
* Create Metric Filters to count occurrences of specific patterns e.g., number of failed tests.
* Set up Alarms based on these metrics to notify teams via SNS if a critical threshold e.g., more than 5 test failures in 5 minutes is crossed.
* Playwright Tracing: Playwright's trace viewer `npx playwright show-trace trace.zip` is incredibly powerful for debugging failed tests. You can save `trace.zip` to S3 and then download it locally for detailed analysis, including step-by-step execution, network requests, and DOM snapshots.
# Securely Managing Credentials with AWS Secrets Manager
Automated tests often require credentials for logging into applications or accessing APIs. Hardcoding these is a significant security risk.
AWS Secrets Manager allows you to securely store and retrieve these sensitive details.
* Storing Secrets: Store application usernames, passwords, API keys, etc., as secrets in Secrets Manager.
* Retrieving Secrets in CodeBuild/Fargate:
1. Grant Permissions: Your CodeBuild service role or ECS task role needs `secretsmanager:GetSecretValue` permissions for the specific secrets.
2. Retrieve in Code:
```javascript
import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager".
const secretsClient = new SecretsManagerClient{ region: process.env.AWS_REGION }.
async function getSecretsecretName {
try {
const command = new GetSecretValueCommand{ SecretId: secretName }.
const data = await secretsClient.sendcommand.
if data.SecretString {
return JSON.parsedata.SecretString.
return null.
} catch error {
console.error"Error retrieving secret:", error.
throw error.
}
// In your test code:
test'user login', async { page } => {
const credentials = await getSecret'your/app/credentials'.
await page.fill'#username', credentials.username.
await page.fill'#password', credentials.password.
// ... rest of the login flow
}.
```
3. Alternative CodeBuild: Use the CodeBuild feature to inject secrets as environment variables directly from Secrets Manager, referencing them in your `buildspec.yml`.
```yaml
# buildspec.yml
env:
secrets-manager:
APP_USERNAME: your/app/credentials:username
APP_PASSWORD: your/app/credentials:password
# In your build phase:
# - Your test script can now access process.env.APP_USERNAME, etc.
This significantly enhances the security posture of your automated tests, moving away from insecure practices.
These advanced integrations transform Playwright execution on AWS into a robust, observable, and secure testing framework, enabling teams to build confidence in their deployments.
Cost Optimization and Performance Tuning for Playwright on AWS
Running Playwright tests in the cloud offers immense scalability but also requires careful consideration of costs and performance.
Optimizing your AWS resources can lead to significant savings and faster feedback loops, making your testing pipeline more efficient.
# Cost Optimization Strategies
AWS operates on a pay-as-you-go model.
Understanding how Playwright consumes resources allows for targeted cost savings.
* Right-Sizing Compute Resources Fargate/CodeBuild:
* CPU and Memory: This is the most critical factor. Playwright is memory-intensive due to browser processes. Over-provisioning leads to wasted spend, while under-provisioning causes slow tests or failures.
* Start small, then scale up: Begin with conservative CPU/memory allocations e.g., 1 vCPU, 4GB RAM for Fargate. `general1.medium` for CodeBuild.
* Monitor resource utilization: Use CloudWatch metrics for ECS tasks CPUUtilization, MemoryUtilization or CodeBuild build metrics. If CPU is consistently low e.g., <30% but memory is high, you might need more memory but less CPU. If both are low, you can downsize.
* Parallelism: Match Playwright's `--workers` count to your vCPU allocation. For example, on a 2 vCPU Fargate task, setting `--workers=2` or `--workers=3` is usually optimal. Too many workers can lead to contention and slowdowns rather than speedups.
* Instance Types EC2: If using EC2, select instance types optimized for compute or memory e.g., C-series for compute, R-series for memory based on your profiling, though Fargate often simplifies this.
* Ephemeral Nature of Resources:
* Run-on-demand: Only spin up Fargate tasks or CodeBuild instances when tests need to run e.g., triggered by a CI/CD pipeline. Do not keep instances running continuously if not needed.
* Delete old artifacts: Regularly clean up old Playwright reports, screenshots, and videos from S3. While S3 storage is cheap, it accumulates over time. Implement S3 lifecycle policies to automatically transition older objects to lower-cost storage tiers e.g., S3 Glacier or delete them after a certain period.
* Networking Costs: Data transfer costs can add up.
* Region proximity: Run tests in the same AWS region as your application under test to minimize data transfer latency and costs between regions.
* Public IP costs: For Fargate, assigning a public IP address to each task adds a small cost. If your application is in a private VPC and you're using VPC endpoints, consider running tasks without public IPs, relying on a NAT Gateway which has its own costs or VPC peering.
* Managed Services over Self-Managed: Prefer Fargate, CodeBuild, and S3 over self-managing EC2 instances, Docker registries, or storage. Managed services abstract away operational overhead and often offer better cost-effectiveness for intermittent workloads.
# Performance Tuning Strategies
Faster test execution means quicker feedback to developers, accelerating the development cycle.
* Test Code Optimization:
* Efficient Selectors: Use robust, performant Playwright selectors e.g., `getByRole`, `getByText`, `getByTestId` over fragile CSS/XPath selectors.
* Reduce Redundancy: Avoid unnecessary waits or repetitive actions within tests.
* Modularize Tests: Break down large tests into smaller, focused units.
* Mock Network Requests: For unit or component tests, mock API calls using `page.route` to avoid external dependencies and speed up execution. This reduces reliance on a live backend.
* Playwright Configuration:
* `playwright.config.ts` Parallelism `workers`: Configure the number of parallel workers in your Playwright config to match your available CPU cores. For example, `workers: process.env.CI ? 4 : undefined,` to use 4 workers in CI/CD environments.
* Browser Headless Mode: Always run Playwright in headless mode `headless: true` is default when on AWS. This significantly reduces resource consumption CPU and memory compared to running a visible browser UI.
* Retries `retries`: Configure retries for flaky tests in `playwright.config.ts`. While this doesn't speed up successful tests, it prevents unnecessary full test suite re-runs due to transient failures, improving overall pipeline efficiency.
* Timeouts `timeout`: Set appropriate timeouts for tests and actions. Long timeouts can hide performance issues.
* AWS Infrastructure Optimization:
* Network Performance: Ensure your VPC, subnets, and security groups are configured optimally to allow efficient communication between your Playwright tests and the application under test.
* S3 Performance: For very high-frequency uploads of artifacts, consider S3 transfer acceleration if latency to S3 is an issue, though this is rarely necessary for Playwright artifacts.
* Ephemeral Storage Fargate: Fargate tasks typically have 20GB of ephemeral storage. This is usually sufficient for Playwright, but be aware of its limits if you generate extremely large temporary files.
By diligently applying these cost optimization and performance tuning techniques, you can build a highly efficient, fast, and budget-friendly Playwright testing pipeline on AWS, maximizing your return on investment in automated quality assurance.
Managing Playwright Tests in AWS CI/CD Pipelines
Integrating Playwright tests into your Continuous Integration/Continuous Delivery CI/CD pipeline on AWS is essential for achieving true automation and rapid feedback.
AWS CodePipeline, CodeBuild, and CodeCommit or GitHub/GitLab integration form a powerful ecosystem for this purpose.
A well-designed CI/CD pipeline ensures that every code change is automatically validated against your Playwright test suite, catching regressions early.
# Designing a Playwright CI/CD Pipeline with CodePipeline
A typical pipeline for web applications involving Playwright tests might look like this:
1. Source Stage:
* Provider: AWS CodeCommit, GitHub, GitLab, or S3.
* Action: Detects changes in your repository e.g., a push to the `main` branch.
* Output: Source code artifact.
2. Build Stage CodeBuild:
* Action: Compiles your application code if applicable and/or sets up the environment for testing.
* Input: Source code artifact from the Source Stage.
* Buildspec: Executes a `buildspec.yml` file to:
* Install Node.js dependencies.
* Install Playwright browsers `npx playwright install --with-deps`.
* Run Playwright tests `npm test` or `npx playwright test`.
* Crucial: The CodeBuild project must be configured with sufficient CPU/memory for Playwright and the correct IAM role for accessing any necessary resources e.g., S3 for artifacts, Secrets Manager for credentials.
* Output: If successful, can include a "test passed" artifact. If tests fail, the build fails, and the pipeline stops.
3. Deploy Stage Optional, but Recommended:
* Action: Deploys your application to a staging/UAT environment e.g., AWS Elastic Beanstalk, ECS Fargate, EC2.
* Input: Application build artifact if your application was built in the same pipeline.
4. Test Stage Post-Deployment - CodeBuild/Fargate:
* Action: Runs more extensive end-to-end Playwright tests against the *deployed application* in the staging environment. This is critical for validating the entire stack.
* Input: Information about the deployed application's URL.
* Execution: Can be another CodeBuild project which might run `npx playwright test` after `npm install` and `npx playwright install --with-deps` or trigger an ECS Fargate task specifically designed for post-deployment E2E testing.
* Important: The Playwright tests in this stage should point to the newly deployed application's URL, often passed as an environment variable e.g., `BASE_URL`.
* Failure: If these post-deployment tests fail, the pipeline can be configured to roll back the deployment or halt further progression.
5. Manual Approval Stage Optional:
* Action: Allows for manual review before deploying to production.
6. Production Deploy Stage:
* Action: Deploys the application to the production environment.
# Best Practices for CI/CD Integration
* Fast Feedback Loop: Prioritize running essential, fast-running Playwright tests early in the pipeline e.g., in the initial CodeBuild stage after code changes to provide quick feedback. More comprehensive, slower E2E tests can run against deployed environments.
* Environment Variables: Use environment variables extensively to configure your Playwright tests for different environments dev, staging, prod. AWS Parameter Store or Secrets Manager can provide these securely to CodeBuild/Fargate.
* Artifact Management: Consistently upload Playwright reports, screenshots, and videos to S3 for easy access and debugging. Automate cleanup of old artifacts to manage costs.
* Granular Permissions: Ensure your CodeBuild service roles and ECS task roles have the principle of least privilege, granting only the necessary permissions to execute tests and interact with other AWS services e.g., S3, Secrets Manager, CloudWatch.
* Test Isolation: Design tests to be independent and repeatable. Avoid tests that rely on the state of previous tests.
* Parallelization: Leverage Playwright's `--workers` and AWS's scaling capabilities CodeBuild compute types, Fargate CPU/memory to run tests in parallel, significantly reducing execution time.
* Reporting and Notifications:
* CloudWatch Alarms: Set up alarms on CloudWatch Logs for test failures to notify teams via SNS or other channels.
* CodePipeline Notifications: Configure CodePipeline to send notifications e.g., via SNS to Slack or email on pipeline status changes success, failure, manual approval required.
* Infrastructure as Code IaC: Define your CodePipeline, CodeBuild projects, ECS task definitions, and S3 buckets using IaC tools like AWS CloudFormation or Terraform. This ensures consistent, repeatable, and version-controlled infrastructure.
By meticulously integrating Playwright into your AWS CI/CD pipelines, you create a robust, automated quality gate that ensures the reliability and stability of your applications, empowering your development team to deliver high-quality software with confidence.
Troubleshooting Common Playwright AWS Issues
Even with careful setup, you might encounter issues when running Playwright tests on AWS.
Understanding common pitfalls and their solutions can save significant debugging time.
# 1. Browser Not Found or Not Launching Fargate/CodeBuild
Symptom: Tests fail with errors like "Browser type 'chromium' is not found." or "Failed to launch browser: Timeout 30000ms exceeded."
Root Causes & Solutions:
* Missing browser binaries:
* Cause: The Docker image or CodeBuild environment does not have the Playwright browsers and their system dependencies installed.
* Solution: In your Dockerfile or CodeBuild `install` phase, ensure you run `npx playwright install --with-deps chromium firefox webkit`. The `--with-deps` part is critical as it installs necessary OS libraries e.g., fonts, graphics libraries.
* Verification: Temporarily add `RUN ls -l /ms-playwright/` or similar commands to your Dockerfile to verify browser installation path.
* Incorrect base image:
* Cause: Using a minimalistic Node.js image without Playwright pre-installed, and `npx playwright install --with-deps` failed or wasn't run.
* Solution: Use an official Playwright base image e.g., `mcr.microsoft.com/playwright/node:lts` which comes with browsers. If not, explicitly run the install command.
* Insufficient CPU/Memory:
* Cause: The Fargate task or CodeBuild instance does not have enough resources to launch the browser. Browsers, especially Chromium, are resource-hungry.
* Solution: Increase the `cpu` and `memory` allocated to your Fargate task definition or select a larger compute type for your CodeBuild project `build.general1.medium` or `large`. Start with 1 vCPU and 4GB RAM, then increase.
* Networking issues:
* Cause: The container cannot reach the Playwright CDN during `npx playwright install` or cannot resolve the application URL during tests.
* Solution:
* Ensure your Fargate task's subnet has outbound internet access via NAT Gateway for private subnets or direct public IP for public subnets.
* Verify security groups allow outbound traffic on common ports 80, 443.
# 2. Tests Are Slow or Time Out
Symptom: Playwright tests take much longer than expected, or individual actions time out.
* Insufficient Resources:
* Cause: Not enough CPU or memory for the number of parallel workers. Browsers become sluggish, leading to timeouts.
* Solution: Increase `cpu` and `memory` in your Fargate task definition or CodeBuild instance type. Adjust Playwright's `workers` setting in `playwright.config.ts` to be appropriate for the allocated resources e.g., `workers: Math.flooros.cpus.length / 2` or a fixed number based on profiling.
* Network Latency:
* Cause: Your Playwright tests are running in a different AWS region or VPC than your application under test, introducing high network latency.
* Solution: Deploy your Playwright testing infrastructure Fargate tasks, CodeBuild in the same AWS region and ideally the same VPC as your application.
* Flaky Elements/Application Issues:
* Cause: The application under test itself is slow, or elements are not consistently loading, leading to Playwright's default actionability checks timing out.
* Solution: Profile your application. For tests, use Playwright's `locator.waitFor` or `expectlocator.toBeVisible` with increased timeouts for specific slow elements if necessary, but primarily address the underlying application performance.
* Excessive Logging/Artifact Generation:
* Cause: Too much logging or generating large artifacts screenshots, videos for every step can add overhead.
* Solution: Configure `screenshot: 'only-on-failure'` and `video: 'on-first-retry'` in `playwright.config.ts` for efficiency. Fine-tune log levels.
# 3. Permissions Denied Accessing S3, Secrets Manager, etc.
Symptom: Tests fail with "Access Denied" when trying to upload artifacts to S3 or retrieve secrets.
* Incorrect IAM Role:
* Cause: The IAM role associated with your Fargate task `taskRoleArn` or CodeBuild project's service role does not have the necessary permissions.
* For S3: Add `s3:PutObject`, `s3:GetObject`, `s3:ListBucket` permissions for the specific bucket and object paths `arn:aws:s3:::your-bucket-name/*`.
* For Secrets Manager: Add `secretsmanager:GetSecretValue` for the specific secret ARNs `arn:aws:secretsmanager:your-region:your-account-id:secret:your/secret/name-*`.
* For CloudWatch Logs: The `ecsTaskExecutionRole` for Fargate or CodeBuild's default role usually handles this, but ensure `logs:CreateLogGroup`, `logs:CreateLogStream`, `logs:PutLogEvents` are present for the target log group.
* Resource Policy Issues:
* Cause: The S3 bucket policy or Secrets Manager policy might implicitly deny access, even if your IAM role has permissions explicit deny overrides allow.
* Solution: Review resource-based policies to ensure they don't block access from your testing environment's IAM roles.
# 4. Docker Image Size and Build Time Issues
Symptom: Docker image builds are very slow, or the resulting image is excessively large, impacting ECR push/pull times.
* Inefficient Dockerfile:
* Cause: Not leveraging Docker caching, installing unnecessary packages, or copying too many files.
* Order your Dockerfile layers from least to most frequently changing e.g., `COPY package*.json` then `RUN npm install` *before* `COPY . .`.
* Use multi-stage builds to only include necessary runtime dependencies in the final image.
* Crucial: Use an official Playwright base image e.g., `mcr.microsoft.com/playwright/node:lts` which is optimized and includes browsers, reducing your own Dockerfile complexity and potential errors.
* Remove build-time dependencies that aren't needed at runtime.
* Large `node_modules`:
* Cause: `node_modules` can grow very large.
* Solution: Use `.dockerignore` to exclude unnecessary files and folders e.g., `.git`, `node_modules` if you're installing them inside the container, `test-results`, `playwright-report`.
* Excessive Browser Installation:
* Cause: Installing all browsers `chromium`, `firefox`, `webkit` when only one is needed, or installing browsers manually when the base image already provides them.
* Solution: Only install the browsers you actually use. If using an official Playwright base image, you often don't need `npx playwright install` unless you need a very specific version.
By systematically addressing these common issues, you can build a stable and efficient Playwright testing environment on AWS, ensuring your automated tests provide reliable feedback and accelerate your development cycle.
Ensuring Halal Practices in Your Development and Testing Workflow
As Muslim professionals, our work, including the development and testing of software, should always align with Islamic principles. While the topic of "Playwright AWS" is technical and seemingly neutral, the *purpose* and *content* of the applications we build and test are paramount. It is crucial to ensure that our efforts contribute to what is good and permissible halal and steer clear of anything that is forbidden haram.
# What to Avoid in Application Development and Testing
When we are developing or testing applications, we must be mindful of the underlying business, content, and functionality.
We should actively discourage and avoid involvement with applications or systems that facilitate or promote:
* Riba Interest-based transactions and Financial Fraud: This includes testing features for conventional banking, interest-based loans, credit cards that charge interest, gambling platforms, speculative financial products, or any system involved in financial scams.
* Alternative: Focus on testing applications for halal finance, ethical investments, honest trade platforms, and Zakat management systems. Ensure financial logic adheres to Sharia principles like risk-sharing and asset-backed transactions.
* Gambling and Betting: Any application involving games of chance with monetary stakes, lotteries, or sports betting is strictly forbidden. Testing these systems would directly support haram activities.
* Alternative: Direct your skills towards educational games, productivity tools, or skill-based, non-gambling entertainment applications.
* Intoxicants Alcohol, Cannabis, Narcotics: Developing or testing e-commerce platforms selling alcohol, cannabis products, or any form of narcotics, or related advertising platforms, is impermissible.
* Alternative: Focus on applications for health and wellness excluding those promoting impermissible substances, educational platforms, or e-commerce for halal goods and services.
* Immoral Behavior and Indecency: This encompasses applications promoting pornography, inappropriate content, dating apps, platforms for illicit relationships, or content that exploits human sexuality. It also extends to services that normalize or facilitate LGBTQ+ lifestyles, as these are contrary to Islamic teachings on family and gender.
* Alternative: Channel your expertise into family-friendly content, applications that strengthen community bonds, facilitate righteous marriages, or promote modesty and ethical conduct.
* Pork and Non-Halal Food Products: Testing supply chain software or e-commerce platforms explicitly dealing with pork or other non-halal meat/food products.
* Alternative: Prioritize systems for halal food sourcing, certification, and distribution, or general e-commerce for permissible goods.
* Idol Worship, Polytheism, Black Magic, Astrology: Any digital platform or service that promotes or facilitates practices contrary to the pure monotheism of Islam Tawhid, including astrology, fortune-telling, or content related to black magic.
* Alternative: Contribute to applications that promote Islamic knowledge, Quranic studies, prayer times, Hadith resources, or those based on sound scientific principles.
* Podcast, Movies, and Mainstream Entertainment If they contain Haram elements: While opinions vary on certain forms of entertainment, applications primarily focused on podcast streaming, movies, or general entertainment platforms that contain significant elements of immodesty, violence, or themes contrary to Islamic ethics should be approached with caution or avoided.
* Alternative: Focus on educational media, informative documentaries, family-appropriate content, or platforms for Islamic lectures and nasheeds vocal podcast without instruments.
# Guiding Principles for Muslim Professionals
1. Intention Niyyah: Our intention behind the work should be to earn a permissible livelihood and to contribute positively to society, avoiding any actions that directly or indirectly support sin.
2. Due Diligence: Before engaging with a project, understand the nature of the application and its purpose. If it clearly falls into a forbidden category, decline the engagement.
3. Seeking Halal Alternatives: Actively seek opportunities that align with Islamic values. There is abundant permissible work in the tech industry that serves humanity righteously. For instance, testing an application for a charitable organization, an educational platform, a medical service, or a halal e-commerce site would be highly commendable.
4. Counseling Naseeha: If possible and appropriate, offer sincere advice to colleagues or clients if they are involved in developing impermissible applications, gently guiding them towards better, halal alternatives.
5. Purity of Earning: Ensure that the income derived from our work is entirely halal, free from any taint of forbidden activities.
By adhering to these principles, we can ensure that our professional skills in software development and testing, including advanced topics like Playwright with AWS, are utilized in a manner that is pleasing to Allah SWT and beneficial for ourselves and the wider community.
Our ultimate goal is success in this life and the Hereafter, and that comes through righteousness and avoiding that which is forbidden.
Frequently Asked Questions
# What is Playwright AWS?
Playwright AWS refers to the practice of running Playwright end-to-end tests on Amazon Web Services AWS infrastructure.
This typically involves containerizing Playwright tests using Docker, pushing them to Amazon ECR, and then executing them on serverless compute services like AWS Fargate via ECS or within a Continuous Integration/Continuous Delivery CI/CD pipeline using AWS CodeBuild.
# Why should I run Playwright tests on AWS?
Running Playwright tests on AWS offers significant advantages such as scalability, reliability, cost-efficiency, and seamless integration with CI/CD pipelines.
It allows you to run tests in parallel, reduce local resource consumption, and ensure consistent testing environments, leading to faster feedback cycles and improved application quality.
# What AWS services are commonly used with Playwright?
The most common AWS services used with Playwright are:
* Amazon ECS with Fargate launch type: For running containerized tests without managing servers.
* AWS CodeBuild: For executing tests within CI/CD pipelines.
* Amazon ECR: For storing Docker images of your Playwright tests.
* Amazon S3: For storing test artifacts like reports, screenshots, and videos.
* AWS CloudWatch: For logging and monitoring test execution.
* AWS Secrets Manager/Parameter Store: For securely managing test credentials and configurations.
# Can I run Playwright on AWS Lambda?
Yes, you can run Playwright on AWS Lambda, but it's generally not recommended for full-fledged end-to-end test suites. Lambda has limitations such as a 15-minute execution timeout, a 500MB deployment package size limit which can be a challenge for browser binaries, and limited ephemeral storage. While it might work for very short, isolated browser interactions or specific page scraping tasks, it's less suitable for complex, long-running, or parallel Playwright tests. AWS Fargate is a much better fit for typical Playwright test execution.
# How do I containerize Playwright for AWS?
To containerize Playwright for AWS, you need to create a `Dockerfile`. This Dockerfile should typically start from an official Playwright base image e.g., `mcr.microsoft.com/playwright/node:lts`, copy your test code, install Node.js dependencies, and ensure Playwright browsers are installed `npx playwright install --with-deps`. Once built, you push this Docker image to Amazon ECR.
# What are the recommended CPU and Memory for Playwright on AWS Fargate?
For Playwright tests on AWS Fargate, a good starting point for CPU and memory allocation is 1 vCPU 1024 CPU units and 4GB of RAM 4096MB. For more intensive or parallel tests, you might need to scale up to 2 vCPUs 2048 CPU units and 8GB of RAM 8192MB. Browser instances, especially Chromium, consume significant memory, so monitor CloudWatch metrics and adjust as needed.
# How do I pass environment variables to my Playwright tests on AWS?
You can pass environment variables to your Playwright tests on AWS in several ways:
* ECS Task Definition: Define `environment` variables within the `containerDefinitions` section of your JSON task definition.
* CodeBuild: Use the `env` section in your `buildspec.yml` or configure them directly in the CodeBuild project settings.
* Secrets Manager/Parameter Store: Retrieve dynamic or sensitive variables programmatically within your test code using the AWS SDK, or in CodeBuild configure them to be injected directly from these services.
# How do I store Playwright test reports and artifacts on AWS?
You can store Playwright test reports like the HTML report, screenshots, and videos in Amazon S3. After your tests run e.g., in a CodeBuild project or Fargate task, use the AWS CLI `aws s3 cp` command to upload the `playwright-report` directory and `test-results` folder to a designated S3 bucket. Ensure your AWS IAM role has `s3:PutObject` permissions.
# How can I monitor Playwright test execution on AWS?
You can monitor Playwright test execution using AWS CloudWatch Logs. Configure your ECS task definitions or CodeBuild projects to send container/build logs to a CloudWatch Log Group. You can then view test output, errors, and Playwright console logs directly in the CloudWatch console, create metric filters for failure patterns, and set up alarms for critical issues.
# How do I integrate Playwright tests into an AWS CI/CD pipeline?
You integrate Playwright tests into an AWS CI/CD pipeline using AWS CodePipeline to orchestrate stages and AWS CodeBuild for the actual test execution. CodePipeline monitors your source repository e.g., CodeCommit, GitHub, triggers CodeBuild on code changes, which then runs your containerized Playwright tests defined in a `buildspec.yml`. You can add stages for pre-deployment and post-deployment E2E tests.
# What should be in my `buildspec.yml` for Playwright on CodeBuild?
Your `buildspec.yml` should include:
* An `install` phase to run `npm install` and `npx playwright install --with-deps` to install browsers and their system dependencies.
* A `build` phase to run your tests e.g., `npm test` or `npx playwright test`.
* A `post_build` phase to generate reports and upload artifacts to S3 using `aws s3 cp`.
# How can I ensure my Playwright tests are secure on AWS?
To ensure security:
* Securely manage credentials: Use AWS Secrets Manager or Parameter Store for sensitive data instead of hardcoding.
* Least privilege IAM roles: Grant only the necessary permissions to your ECS task roles and CodeBuild service roles.
* Private networking: If possible, run your tests in private subnets and restrict inbound access using security groups.
* Regularly review S3 bucket policies: Ensure artifacts are not publicly accessible unless intentionally so e.g., a public HTML report.
# What are the challenges of running Playwright on AWS?
Challenges include:
* Resource allocation: Correctly sizing CPU and memory for Fargate tasks/CodeBuild instances.
* Docker image size: Managing large Docker images with browser binaries.
* Network configuration: Ensuring proper VPC, subnet, and security group setup for outbound access and application reachability.
* Debugging: Understanding how to access logs and artifacts for troubleshooting.
* Cost management: Optimizing resource usage to prevent unnecessary expenses.
# How can I optimize costs for Playwright tests on AWS?
Optimize costs by:
* Right-sizing resources: Allocate just enough CPU/memory for your Fargate tasks or CodeBuild instances.
* Leveraging serverless: Use Fargate/CodeBuild which are pay-per-use, avoiding idle server costs.
* Deleting old artifacts: Implement S3 lifecycle policies to automatically clean up old test reports and artifacts.
* Choosing the right region: Run tests in the same region as your application to minimize data transfer costs.
# Can Playwright run in headless mode on AWS?
Yes, Playwright runs in headless mode by default, which is the standard and recommended practice when executing tests on AWS.
Headless mode means the browser UI is not rendered, saving significant CPU and memory resources, making it ideal for cloud environments.
# Is it possible to use Playwright for visual regression testing on AWS?
Yes, you can use Playwright for visual regression testing on AWS.
Playwright captures screenshots, which can then be uploaded to S3. You can integrate a visual comparison tool either self-hosted or a third-party service into your CI/CD pipeline on CodeBuild to compare these new screenshots against baseline images stored in S3, flagging any visual differences.
# How do I troubleshoot "no space left on device" errors on AWS?
This error usually indicates insufficient ephemeral storage on your Fargate task or CodeBuild instance.
While Fargate tasks typically have 20GB of ephemeral storage which is usually enough, ensure your tests are not generating excessively large temporary files.
If using EC2, verify your instance's root volume size.
For CodeBuild, ensure you're not trying to download massive external files into the build environment.
# What is the advantage of using Playwright's tracing feature with AWS?
Playwright's tracing feature `trace: 'on'` captures a rich log of browser operations, network requests, and DOM snapshots.
When run on AWS, these trace files `trace.zip` can be uploaded to S3. This allows you to download and view them locally with the Playwright Trace Viewer `npx playwright show-trace`, providing invaluable debugging information for test failures that occur in your remote AWS environment, mimicking local debugging capabilities.
# How do I ensure Playwright tests are running against the correct environment URL on AWS?
You should pass the target application URL as an environment variable to your Playwright tests.
In your `playwright.config.ts`, you can read this variable e.g., `process.env.BASE_URL`. This environment variable can be set dynamically in your ECS task definition, CodeBuild project, or CodePipeline, ensuring tests run against development, staging, or production environments as needed.
# What IAM permissions are needed for CodeBuild to run Playwright tests and upload artifacts?
For CodeBuild to run Playwright tests and upload artifacts, its service role needs:
* `logs:CreateLogGroup`, `logs:CreateLogStream`, `logs:PutLogEvents` for CloudWatch Logs.
* `s3:PutObject`, `s3:GetObject`, `s3:ListBucket` for the S3 bucket where artifacts are stored.
* `ecr:GetAuthorizationToken`, `ecr:BatchCheckLayerAvailability`, `ecr:GetDownloadUrlForLayer`, `ecr:BatchGetImage` if it's pulling a private ECR image.
* `secretsmanager:GetSecretValue` if accessing secrets from Secrets Manager.
|
0.0 out of 5 stars (based on 0 reviews)
There are no reviews yet. Be the first one to write one. |
Amazon.com:
Check Amazon for Playwright aws Latest Discussions & Reviews: |
Leave a Reply