Multi-Platform Deployment

Comprehensive deployment guidance for web applications, mobile apps, and blockchain smart contracts.

Web Application Deployment

Static Site Deployment

Vercel:

# Install CLI
npm i -g vercel

# Deploy
vercel --prod

# With environment variables
vercel --prod -e DATABASE_URL=@database-url

Netlify:

# Install CLI
npm i -g netlify-cli

# Deploy
netlify deploy --prod --dir=dist

AWS S3 + CloudFront:

# Sync to S3
aws s3 sync dist/ s3://my-bucket --delete

# Invalidate CloudFront cache
aws cloudfront create-invalidation \
  --distribution-id $DIST_ID \
  --paths "/*"

Container Deployment

Docker Build & Push:

# Dockerfile
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80

# Build and push
docker build -t myapp:latest .
docker tag myapp:latest registry.example.com/myapp:latest
docker push registry.example.com/myapp:latest

Kubernetes Deployment

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: registry.example.com/myapp:latest
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        readinessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

# Apply deployment
kubectl apply -f deployment.yaml

# Rolling update
kubectl set image deployment/myapp myapp=registry.example.com/myapp:v2

# Rollback
kubectl rollout undo deployment/myapp

Mobile App Deployment

iOS App Store

Prerequisites:

• Apple Developer account ($99/year)
• App Store Connect access
• Distribution certificate and provisioning profile

Deployment Steps:

1. Archive app in Xcode
2. Validate archive
3. Upload to App Store Connect
4. Submit for review
5. Release upon approval

Fastlane Automation:

# Fastfile
default_platform(:ios)

platform :ios do
  lane :release do
    increment_build_number
    build_app(scheme: "MyApp")
    upload_to_app_store(
      skip_metadata: true,
      skip_screenshots: true
    )
  end
end

# Run deployment
fastlane release

Google Play Store

Prerequisites:

• Google Play Console account ($25 one-time)
• App signing key
• Service account for API access

Fastlane for Android:

# Fastfile
default_platform(:android)

platform :android do
  lane :release do
    gradle(task: "bundleRelease")
    upload_to_play_store(
      track: "production",
      aab: "app/build/outputs/bundle/release/app-release.aab"
    )
  end
end

Cross-Platform (Expo/EAS)

# Configure EAS
eas build:configure

# Build for both platforms
eas build --platform all --profile production

# Submit to stores
eas submit --platform ios
eas submit --platform android

Blockchain Deployment

Ethereum Mainnet

// deploy.js (Hardhat)
async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying with:", deployer.address);

  const Contract = await ethers.getContractFactory("MyContract");
  const contract = await Contract.deploy(constructorArg1, constructorArg2);
  await contract.waitForDeployment();

  console.log("Contract deployed to:", await contract.getAddress());

  // Verify on Etherscan
  await hre.run("verify:verify", {
    address: await contract.getAddress(),
    constructorArguments: [constructorArg1, constructorArg2],
  });
}

Foundry Deployment:

# Deploy
forge create src/MyContract.sol:MyContract \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --constructor-args arg1 arg2

# Verify
forge verify-contract $ADDRESS src/MyContract.sol:MyContract \
  --chain mainnet \
  --etherscan-api-key $ETHERSCAN_KEY

Multi-Chain Deployment

// Deploy to multiple chains
const chains = {
  ethereum: { rpc: process.env.ETH_RPC, chainId: 1 },
  polygon: { rpc: process.env.POLYGON_RPC, chainId: 137 },
  arbitrum: { rpc: process.env.ARB_RPC, chainId: 42161 },
  base: { rpc: process.env.BASE_RPC, chainId: 8453 }
};

async function deployToAllChains() {
  const deployments = {};

  for (const [name, config] of Object.entries(chains)) {
    const provider = new ethers.JsonRpcProvider(config.rpc);
    const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

    const factory = new ethers.ContractFactory(abi, bytecode, wallet);
    const contract = await factory.deploy();
    await contract.waitForDeployment();

    deployments[name] = await contract.getAddress();
    console.log(`Deployed to ${name}: ${deployments[name]}`);
  }

  return deployments;
}

Deployment Strategies

Blue-Green Deployment

┌─────────────┐     ┌─────────────┐
│   Router    │     │   Router    │
└──────┬──────┘     └──────┬──────┘
       │                   │
   ┌───┴───┐           ┌───┴───┐
   ▼       ▼           ▼       ▼
┌─────┐ ┌─────┐     ┌─────┐ ┌─────┐
│Blue │ │Green│  →  │Blue │ │Green│
│ ✓   │ │     │     │     │ │  ✓  │
└─────┘ └─────┘     └─────┘ └─────┘

Canary Deployment

# Kubernetes canary with Istio
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: myapp
spec:
  hosts:
  - myapp
  http:
  - route:
    - destination:
        host: myapp
        subset: stable
      weight: 90
    - destination:
        host: myapp
        subset: canary
      weight: 10

Rolling Update

# Kubernetes rolling update
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

Environment Management

Environment Variables

# Development
cp .env.example .env.development

# Staging
cp .env.example .env.staging

# Production (use secrets manager)
aws secretsmanager get-secret-value --secret-id prod/myapp

Feature Flags

// LaunchDarkly example
const ldclient = LaunchDarkly.init(process.env.LD_SDK_KEY);

const showNewFeature = await ldclient.variation(
  'new-feature',
  { key: user.id },
  false
);

Deployment Checklist

Pre-Deployment

• All tests passing
• Code reviewed and approved
• Database migrations ready
• Environment variables configured
• Rollback plan documented
• Monitoring alerts configured

Post-Deployment

• Health checks passing
• Smoke tests executed
• Performance metrics normal
• Error rates acceptable
• Notify stakeholders

Additional Resources

Reference Files

• references/cloud-providers.md

  - Provider-specific deployment guides

• references/deployment-scripts.md

  - Reusable deployment scripts

Example Files

• examples/k8s-deployment.yaml

  - Complete Kubernetes manifests

• examples/github-deploy-workflow.yml

  - CI/CD deployment workflow