The Showcase

Ensure that Docker Compose is properly installed and accessible in your environment before proceeding with multi-service application setup.

docker compose version

Define the services required for your application in a compose.yaml file. This includes both a web service and a database service.

version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    depends_on:
      - db
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data
volumes:
  db_data:

Deploy the defined services in detached mode using the docker compose up command.

docker compose up -d

Monitor the logs of your running services to verify that they are starting correctly and to troubleshoot any issues.

docker compose logs -f

The first step is to authenticate your local Stripe CLI with your Stripe account. This allows the CLI to access your test environment and manage webhooks.

stripe login

This command initiates the Stripe CLI webhook listener, which forwards incoming test events to your local development server endpoint.

stripe listen --forward-to localhost:4242/webhook

Using the CLI, you can simulate real webhook events such as checkout.session.completed to test your local webhook handler.

stripe trigger checkout.session.completed

The Vercel CLI must be installed globally on your system to enable command-line deployment capabilities.

npm i -g vercel

Authentication is required to associate deployments with your Vercel account and manage permissions.

vercel login

This command deploys your local project to a temporary preview URL for testing before production deployment.

vercel

The --prod flag ensures the deployment is made live and accessible at a permanent URL.

vercel --prod

Install the Wrangler CLI tool as a development dependency to interact with Cloudflare Pages.

npm install -D wrangler

Authenticate your Cloudflare account with the Wrangler CLI using the login command.

npx wrangler login

Deploy the contents of your build folder to Cloudflare Pages using the deploy command with a specified project name.

npx wrangler pages deploy dist --project-name my-site

Installing Prisma ensures that the necessary tools for schema management and migration are available in your project environment.

npm install prisma --save-dev

Initializing Prisma sets up the required configuration files and directory structure for managing database migrations.

npx prisma init

Adding a model to the Prisma schema file defines the structure of a new table in your database, which will be reflected in subsequent migrations.

model User {
  id    Int    @id @default(autoincrement())
  name  String
  email String @unique
}

Running the dev command with a migration name creates a new migration file based on schema changes and applies it to the database.

npx prisma migrate dev --name init

Install the FastAPI package along with an ASGI server for running the application. The [standard] extra includes uvicorn, which is the recommended ASGI server.

pip install "fastapi[standard]"

Create a main.py file that defines a simple GET endpoint. This step introduces the core FastAPI syntax for defining routes and handling requests.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Start the FastAPI application using the fastapi dev command. This will automatically reload the server on code changes and provide access to interactive API documentation.

fastapi dev main.py

Declare the required provider and define a basic resource to be provisioned. This step sets up the initial configuration for Terraform.

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1d0"
  instance_type = "t2.micro"
}

Run terraform init to download and initialize the required provider plugins and modules.

terraform init

Execute terraform plan to review what changes Terraform will make before applying them.

terraform plan

Use terraform apply to create the declared infrastructure resources in your cloud environment.

terraform apply

Begin by initializing a new Playwright project in your development environment. This command sets up the necessary configuration files and dependencies for testing.

npm init playwright@latest

Execute the test suite using Playwright's built-in test runner. This step runs all defined tests across supported browsers with auto-waiting features enabled.

npx playwright test

After running the tests, generate and open a detailed report to analyze results. This provides insights into test execution, including screenshots and logs.

npx playwright show-report

Initialize a new Next.js project using the create-next-app command to scaffold the basic structure required for an App Router setup.

Create a new directory named 'dashboard' within the app folder and add a page.tsx file to define a route for the dashboard section.

mkdir app/dashboard && touch app/dashboard/page.tsx

Run the development server to preview your Next.js application and verify that the new route is correctly configured with the App Router.

npm run dev

The first step involves creating a deployment using the nginx container image. This command initializes a deployment named 'hello' with the specified image.

kubectl create deployment hello --image=nginx

After creating the deployment, expose it as a NodePort service to make the application accessible from outside the cluster. This allows external traffic to reach the pods.

kubectl expose deployment hello --type=NodePort --port=80

Check the status of the pods created by the deployment to confirm that they are running correctly. This step ensures that the containerized application is properly deployed.

kubectl get pods

Start a Redis instance using Docker to provide an in-memory data store for caching.

docker run -d -p 6379:6379 redis

Install the Python Redis client library to enable interaction with the Redis server from your application.

pip install redis

Use Python to set a key-value pair in Redis with an expiration time, then read it back.

import redis
r = redis.Redis(host='localhost', port=6379, db=0)
r.setex('my_key', 60, 'my_value')
print(r.get('my_key').decode('utf-8'))

To begin automating your CI pipeline, create a workflow file in your repository at .github/workflows/ci.yml. This file defines the actions that GitHub Actions will execute.

mkdir -p .github/workflows
vim .github/workflows/ci.yml

Add a job to your workflow file that checks out the code and runs the automated test command. This ensures tests are executed in a clean environment on every push or pull request.

name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run tests
        run: npm test

After defining your workflow, commit the changes to your repository and push them to GitHub. This triggers the CI pipeline for the first time.

git add .github/workflows/ci.yml
git commit -m "Add CI workflow"
git push