DEV Community: Vaibhav Pawar

Running Playwright Tests in Python with Flask on Cloud Run

Vaibhav Pawar — Sat, 04 Jan 2025 09:29:28 +0000

Automating browser tasks is a breeze with Playwright, and integrating it into a cloud-based service can take your automation capabilities to the next level. In this blog post, we’ll walk you through setting up a Python-based application that uses Flask and Playwright, deploy it to Google Cloud Run, and enable running browser tests through a simple API.

Step 1: Setting Up the Application

We’ll build a Flask app that exposes a POST API to accept a test URL and execute a Playwright test on that URL. To simplify the setup, we’ll keep everything in a single file:
Flask App with Playwright Integration

from flask import Flask, request, jsonify
from playwright.sync_api import sync_playwright
app = Flask(__name__)
# Playwright Test Function
def run_test(test_url):
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.goto(test_url)
        title = page.title()
        browser.close()
    return f"Test completed for {test_url}: {title}"

# Flask Route
@app.route("/", methods=["POST"])
def execute_test():
    # Get JSON payload
    data = request.json
    if not data or "test_url" not in data:
        return jsonify({"error": "Missing 'test_url' in request body"}), 400
    test_url = data["test_url"]
    try:
        result = run_test(test_url)
        return jsonify({"message": result}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 500
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

Key Features

Route Definition: The / route listens for POST requests and expects a JSON payload containing test_url.
Error Handling: Proper validation ensures meaningful error messages for missing or invalid input.
Playwright Test: The run_test function launches a browser, navigates to the provided URL, fetches the page title, and returns the result.

Step 2: Dockerizing the Application

To deploy the application on Cloud Run, we’ll containerize it using Docker. Create a Dockerfile in the same directory as the app.py file.
Dockerfile

FROM python:3.10-slim
# Install Playwright and Flask
RUN apt-get update && apt-get install -y wget curl gnupg libatk-bridge2.0-0 libnss3 libnspr4 && rm -rf /var/lib/apt/lists/*
RUN pip install flask playwright
# Install browser binaries for Playwright
RUN python -m playwright install
# Copy application code
WORKDIR /app
COPY app.py .
# Expose port 8080
EXPOSE 8080
# Run the application
CMD ["python", "app.py"]

Step 3: Deploying to Google Cloud Run

Once your application is containerized, you can deploy it to Google Cloud Run. Follow these steps:

Step 3.1: Build and Push Docker Image
Build the Docker image:

docker build -t gcr.io/<YOUR_PROJECT_ID>/playwright-app .
Push the image to Google Container Registry (GCR):
docker push gcr.io/<YOUR_PROJECT_ID>/playwright-app

Step 3.2: Deploy to Cloud Run
Deploy the service to Cloud Run:


gcloud run deploy playwright-app \ --image=gcr.io/<YOUR_PROJECT_ID>/playwright-app \ --platform managed \ --region <YOUR_REGION> \--allow-unauthenticated
Note the URL provided by Cloud Run after successful deployment.

Step 4: Passing Parameters to the Cloud Run Service

To test specific scenarios, you can pass parameters to your Cloud Run service using a JSON payload. This can be done via tools like curl, Postman, or any HTTP client.
Example JSON Payload

{
    "test_url": "https://example.com"
}

Example curl Command

curl -X POST https://<YOUR_CLOUD_RUN_URL> \
     -H "Content-Type: application/json" \
     -d '{"test_url": "https://example.com"}'

Expected Response

{
    "message": "Test completed for https://example.com: Example Domain"
}

Step 5: Testing the Application

You can test your Cloud Run service using tools like curl or Postman, as shown above. Modify the test_url parameter in the payload to run tests on different URLs.

Troubleshooting
Common Issues

Playwright Dependencies: Ensure all required dependencies are installed.
The Dockerfile includes the necessary packages.
Port Configuration: Cloud Run expects the application to listen on port 8080.
Permission Errors: Ensure the Docker image is accessible by Cloud Run. Debugging Logs

Use the following command to view Cloud Run logs:

gcloud run services logs read playwright-app --region <YOUR_REGION>

Conclusion
In this blog, we’ve shown how to build a Python-based API that leverages Playwright for browser automation, deploy it to Google Cloud Run, and pass parameters to execute specific tests. This setup is ideal for scenarios like website testing, data scraping, or automating repetitive browser tasks. With Cloud Run’s scalability, your service is ready to handle increased demand effortlessly.
Try it out and unlock the power of automated browser testing in the cloud!

Automating Google Cloude Platform Instance Updates with GitHub Actions

Vaibhav Pawar — Tue, 31 Dec 2024 14:06:52 +0000

In this guide, we’ll walk through automating the deployment of updates to a Google Cloud Platform (GCP) instance using GitHub Actions. This workflow simplifies the process of authenticating with GCP, updating the codebase, and restarting the application inside a Docker container.

Objective

The goal is to create a seamless deployment pipeline for a web application running on a GCP Compute Engine instance. This workflow:
Authenticates with GCP using a service account key.
Configures the gcloud CLI for the target project and zone.
Pulls the latest changes from the code repository.
Builds and deploys the application using Docker.

GitHub Actions Workflow Configuration
Below is the GitHub Actions workflow file for the pipeline:

name: Authenticate with GCP and Update Instance
on:
  push:
    branches:
      - main
jobs:
  gcloud-auth:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
    - name: Set up Google Cloud Authentication
      uses: 'google-github-actions/auth@v2'
      with:
        credentials_json: '${{ secrets.GCP_SERVICE_ACCOUNT_KEY }}'



     - name: Install gcloud CLI
      run: |
        sudo apt-get update
        sudo apt-get install -y apt-transport-https ca-certificates gnupg
  echo "deb https://packages.cloud.google.com/apt cloud-sdk main" | sudo      tee   -a /etc/apt/sources.list.d/google-cloud-sdk.list
        curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add - sudo apt-get update && sudo apt-get install -y google-cloud-cli
    - name: Configure gcloud CLI
      run: |
        gcloud config set project ${{ secrets.GCP_SERVICE_ACCOUNT_PROJECT }}
        gcloud config set compute/zone us-central1-a
    - name: Verify Authentication
      run: gcloud compute instances list
    - name: Update Instance with New Changes
      run: |
        gcloud compute ssh ${{ secrets.GCP_SERVICE_ACCOUNT_INSTANCE }} \
          --zone us-central1-a \
          --command "
            sudo su -c 'ls -l / && \
            cd /automation/ && \
            ls -l && \
            git pull && \
            docker build -t client-end . && \
            docker stop client-end-container || true && \
            docker rm client-end-container || true && \
            docker run -d -p 3000:3000 --name client-end-container client-end'"

Steps Breakdown

Checkout the Code The workflow begins by checking out the repository's code using the actions/checkout action. This ensures that the latest changes from the repository are available.

- name: Checkout code
  uses: actions/checkout@v3

Authenticate with GCP This step uses the google-github-actions/auth action to authenticate with GCP. The credentials are securely stored in GitHub Secrets as GCP_SERVICE_ACCOUNT_KEY.

- name: Set up Google Cloud Authentication
  uses: 'google-github-actions/auth@v2'
  with:
    credentials_json: '${{ secrets.GCP_SERVICE_ACCOUNT_KEY }}'

Install gcloud CLI The gcloud CLI is installed on the runner. This tool is necessary for managing GCP resources and executing commands on the Compute Engine instance.

- name: Install gcloud CLI
  run: |
    sudo apt-get update
    sudo apt-get install -y apt-transport-https ca-certificates gnupg
    echo "deb https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
    curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
    sudo apt-get update && sudo apt-get install -y google-cloud-cli

Configure gcloud CLI The gcloud CLI is configured to use the target GCP project and compute zone.

- name: Configure gcloud CLI
  run: |
    gcloud config set project ${{ secrets.GCP_SERVICE_ACCOUNT_PROJECT }}
    gcloud config set compute/zone us-central1-a

Verify Authentication The workflow verifies that the authentication and configuration are correct by listing the Compute Engine instances in the project.

- name: Verify Authentication
  run: gcloud compute instances list

Update the Instance Finally, the workflow connects to the Compute Engine instance via SSH, pulls the latest changes from the repository, builds the Docker image, and deploys it.

- name: Update Instance with New Changes
  run: |
    gcloud compute ssh ${{ secrets.GCP_SERVICE_ACCOUNT_INSTANCE }} \
      --zone us-central1-a \
      --command "
        sudo su -c 'ls -l / && \
        cd /automation/ && \
        ls -l && \
        git pull && \
        docker build -t client-end . && \
        docker stop client-end-container || true && \
        docker rm client-end-container || true && \
        docker run -d -p 3000:3000 --name client-end-container client-end'
      "

Conclusion
This GitHub Actions workflow ensures that the application is automatically updated and redeployed on the GCP Compute Engine instance whenever changes are pushed to the main branch. By integrating GitHub Actions with GCP, this approach provides a reliable, repeatable, and scalable solution for managing deployments.