Evolution of Deployment & DevOps Integration

#!/bin/bash # Simple deployment script circa 2001 # Run as: ./deploy.sh production
ENV=$1 TIMESTAMP=$(date +%Y%m%d_%H%M%S) BACKUP_DIR="/backup/${ENV}_${TIMESTAMP}"
echo "Starting deployment to $ENV environment at $(date)" echo "Creating backup directory $BACKUP_DIR" mkdir -p $BACKUP_DIR
# Back up current application echo "Backing up current application..." tar -czf $BACKUP_DIR/app_backup.tar.gz /var/www/html/
# Back up database echo "Backing up database..." mysqldump -u root -p$DB_PASSWORD myapp_db > $BACKUP_DIR/db_backup.sql
# Stop web server echo "Stopping Apache..." /etc/init.d/apache stop
# Deploy new code echo "Copying new files..." cp -R /tmp/release/* /var/www/html/
# Run database migrations echo "Running database updates..." mysql -u root -p$DB_PASSWORD myapp_db < /var/www/html/db/migrations.sql
# Fix permissions echo "Setting file permissions..." chown -R www-data:www-data /var/www/html/ find /var/www/html/ -type d -exec chmod 755 {} \; find /var/www/html/ -type f -exec chmod 644 {} \;
# Start web server echo "Starting Apache..." /etc/init.d/apache start
echo "Deployment completed at $(date)"

# Example Puppet manifest for a web server circa 2010 node 'webserver.example.com' { # Ensure Apache is installed and running package { 'apache2': ensure => installed, }
service { 'apache2': ensure  => running, enable  => true, require => Package['apache2'], }
# Configure virtual host file { '/etc/apache2/sites-available/myapp.conf': ensure  => file, content => template('myapp/vhost.erb'), require => Package['apache2'], notify  => Service['apache2'], }
# Enable the site exec { 'enable-myapp-site': command => '/usr/sbin/a2ensite myapp.conf', creates => '/etc/apache2/sites-enabled/myapp.conf', require => File['/etc/apache2/sites-available/myapp.conf'], notify  => Service['apache2'], }
# Deploy application code file { '/var/www/myapp': ensure  => directory, owner   => 'www-data', group   => 'www-data', mode    => '0755', recurse => true, source  => 'puppet:///modules/myapp/code', require => Package['apache2'], }
# Install database client package { 'mysql-client': ensure => installed, }
# Install PHP and extensions $php_packages = [ 'php5', 'php5-mysql', 'php5-gd', 'libapache2-mod-php5', ]
package { $php_packages: ensure  => installed, require => Package['apache2'], notify  => Service['apache2'], } }

# Example Ansible playbook circa 2013 ---
name: Configure web servers
hosts: webservers become: yes
tasks:
name: Install Apache
apt: name: apache2 state: present update_cache: yes
name: Ensure Apache is running
service: name: apache2 state: started enabled: yes
name: Deploy virtual host configuration
template: src: templates/vhost.conf.j2 dest: /etc/apache2/sites-available/myapp.conf notify: Reload Apache
name: Enable site
command: a2ensite myapp.conf args: creates: /etc/apache2/sites-enabled/myapp.conf notify: Reload Apache
name: Create application directory
file: path: /var/www/myapp state: directory owner: www-data group: www-data mode: '0755'
name: Deploy application code
copy: src: files/app/ dest: /var/www/myapp owner: www-data group: www-data notify: Reload Apache
name: Install PHP and extensions
apt: name: "{{ item }}" state: present with_items:
php5
php5-mysql
php5-gd
libapache2-mod-php5
notify: Restart Apache
handlers:
name: Reload Apache
service: name: apache2 state: reloaded
name: Restart Apache
service: name: apache2 state: restarted

#!/bin/bash # Example first-boot configuration script for a VM circa 2010 # This would typically be run by cloud-init or similar
# Read environment from metadata service or configuration file ENVIRONMENT=$(curl -s http://169.254.169.254/latest/meta-data/environment) APP_VERSION=$(curl -s http://169.254.169.254/latest/meta-data/app-version) DB_HOST=$(curl -s http://169.254.169.254/latest/meta-data/db-host)
# Configure hostname based on environment HOSTNAME="web-${ENVIRONMENT}-$(hostname | cut -d'-' -f2)" hostname $HOSTNAME echo $HOSTNAME > /etc/hostname echo "127.0.0.1 $HOSTNAME localhost" > /etc/hosts
# Update application configuration CONFIG_FILE="/var/www/myapp/config.php" sed -i "s/DB_HOST = '.*'/DB_HOST = '$DB_HOST'/g" $CONFIG_FILE sed -i "s/APP_ENV = '.*'/APP_ENV = '$ENVIRONMENT'/g" $CONFIG_FILE
# Pull latest application code if needed if [ "$ENVIRONMENT" != "production" ]; then cd /var/www/myapp git pull origin $APP_VERSION chown -R www-data:www-data /var/www/myapp fi
# Register with load balancer echo "Registering with load balancer..." curl -X POST "http://lb-manager.internal/register?host=$(hostname -I | awk '{print $1}')"
# Start application services systemctl start myapp-worker systemctl start myapp-scheduler
echo "First boot configuration completed at $(date)" >> /var/log/firstboot.log

AWSTemplateFormatVersion: '2010-09-09' Description: 'Web application stack with auto scaling'
Parameters: EnvironmentName: Type: String Default: Development AllowedValues: [Development, Staging, Production] Description: Environment name
InstanceType: Type: String Default: t3.small AllowedValues: [t3.small, t3.medium, t3.large] Description: EC2 instance type
Resources: VPC: Type: AWS::EC2::VPC Properties: CidrBlock: 10.0.0.0/16 EnableDnsSupport: true EnableDnsHostnames: true Tags:
Key: Name
Value: !Sub ${EnvironmentName}-VPC
PublicSubnet1: Type: AWS::EC2::Subnet Properties: VpcId: !Ref VPC AvailabilityZone: !Select [0, !GetAZs ''] CidrBlock: 10.0.1.0/24 MapPublicIpOnLaunch: true Tags:
Key: Name
Value: !Sub ${EnvironmentName}-PublicSubnet1
PublicSubnet2: Type: AWS::EC2::Subnet Properties: VpcId: !Ref VPC AvailabilityZone: !Select [1, !GetAZs ''] CidrBlock: 10.0.2.0/24 MapPublicIpOnLaunch: true Tags:
Key: Name
Value: !Sub ${EnvironmentName}-PublicSubnet2
WebServerSecurityGroup: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: Allow HTTP and SSH access VpcId: !Ref VPC SecurityGroupIngress:
IpProtocol: tcp
FromPort: 80 ToPort: 80 CidrIp: 0.0.0.0/0
IpProtocol: tcp
FromPort: 443 ToPort: 443 CidrIp: 0.0.0.0/0
IpProtocol: tcp
FromPort: 22 ToPort: 22 CidrIp: 0.0.0.0/0
WebServerLaunchConfig: Type: AWS::AutoScaling::LaunchConfiguration Properties: ImageId: ami-0abcdef1234567890 # Amazon Linux 2 AMI InstanceType: !Ref InstanceType SecurityGroups:
!Ref WebServerSecurityGroup
UserData: Fn::Base64: !Sub | #!/bin/bash -xe yum update -y yum install -y httpd echo "<html><body><h1>Hello from ${EnvironmentName}</h1></body></html>" > /var/www/html/index.html systemctl start httpd systemctl enable httpd
WebServerGroup: Type: AWS::AutoScaling::AutoScalingGroup Properties: VPCZoneIdentifier:
!Ref PublicSubnet1
!Ref PublicSubnet2
LaunchConfigurationName: !Ref WebServerLaunchConfig MinSize: 2 MaxSize: 5 DesiredCapacity: 2 Tags:
Key: Name
Value: !Sub ${EnvironmentName}-WebServer PropagateAtLaunch: true
Outputs: VPC: Description: VPC ID Value: !Ref VPC
PublicSubnets: Description: Public subnet IDs Value: !Join [", ", [!Ref PublicSubnet1, !Ref PublicSubnet2]]

provider "aws" { region = "us-west-2" }
variable "environment" { description = "Deployment environment" default     = "development" }
resource "aws_vpc" "main" { cidr_block           = "10.0.0.0/16" enable_dns_support   = true enable_dns_hostnames = true
tags = { Name        = "${var.environment}-vpc" Environment = var.environment } }
resource "aws_subnet" "public_a" { vpc_id                  = aws_vpc.main.id cidr_block              = "10.0.1.0/24" availability_zone       = "us-west-2a" map_public_ip_on_launch = true
tags = { Name        = "${var.environment}-public-a" Environment = var.environment } }
resource "aws_subnet" "public_b" { vpc_id                  = aws_vpc.main.id cidr_block              = "10.0.2.0/24" availability_zone       = "us-west-2b" map_public_ip_on_launch = true
tags = { Name        = "${var.environment}-public-b" Environment = var.environment } }
resource "aws_security_group" "web" { name        = "${var.environment}-web-sg" description = "Security group for web servers" vpc_id      = aws_vpc.main.id
ingress { from_port   = 80 to_port     = 80 protocol    = "tcp" cidr_blocks = ["0.0.0.0/0"] }
ingress { from_port   = 443 to_port     = 443 protocol    = "tcp" cidr_blocks = ["0.0.0.0/0"] }
egress { from_port   = 0 to_port     = 0 protocol    = "-1" cidr_blocks = ["0.0.0.0/0"] } }
resource "aws_launch_configuration" "web" { name_prefix     = "${var.environment}-web-" image_id        = "ami-0abcdef1234567890" instance_type   = "t3.small" security_groups = [aws_security_group.web.id]
user_data = <<-EOF #!/bin/bash yum update -y yum install -y httpd echo "<html><body><h1>Hello from ${var.environment}</h1></body></html>" > /var/www/html/index.html systemctl start httpd systemctl enable httpd EOF
lifecycle { create_before_destroy = true } }
resource "aws_autoscaling_group" "web" { name                 = "${var.environment}-web-asg" launch_configuration = aws_launch_configuration.web.name min_size             = 2 max_size             = 5 desired_capacity     = 2 vpc_zone_identifier  = [aws_subnet.public_a.id, aws_subnet.public_b.id]
tag { key                 = "Name" value               = "${var.environment}-web" propagate_at_launch = true }
tag { key                 = "Environment" value               = var.environment propagate_at_launch = true }
lifecycle { create_before_destroy = true } }

# Example Dockerfile for a web application FROM node:14-alpine AS build
WORKDIR /app
# Copy package.json and install dependencies COPY package*.json ./ RUN npm ci
# Copy application code COPY . .
# Build the application RUN npm run build
# Production image FROM nginx:alpine
# Copy built assets from build stage COPY --from=build /app/build /usr/share/nginx/html
# Copy custom nginx config COPY nginx.conf /etc/nginx/conf.d/default.conf
# Expose port EXPOSE 80
# Health check HEALTHCHECK --interval=30s --timeout=3s \ CMD wget -q --spider http://localhost/ || exit 1
# Start nginx CMD ["nginx", "-g", "daemon off;"]

# Example Kubernetes deployment apiVersion: apps/v1 kind: Deployment metadata: name: web-application labels: app: web spec: replicas: 3 selector: matchLabels: app: web strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 0 type: RollingUpdate template: metadata: labels: app: web spec: containers:
name: web
image: mycompany/web-app:1.0.0 ports:
containerPort: 80
resources: limits: cpu: "0.5" memory: "512Mi" requests: cpu: "0.2" memory: "256Mi" livenessProbe: httpGet: path: /health port: 80 initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /ready port: 80 initialDelaySeconds: 5 periodSeconds: 5 env:
name: NODE_ENV
value: "production"
name: DATABASE_URL
valueFrom: secretKeyRef: name: app-secrets key: database-url imagePullSecrets:
name: registry-credentials
--- apiVersion: v1 kind: Service metadata: name: web-service spec: selector: app: web ports:
port: 80
targetPort: 80 type: LoadBalancer

# serverless.yml service: user-api
provider: name: aws runtime: nodejs14.x stage: ${opt:stage, 'dev'} region: us-east-1 environment: TABLE_NAME: ${self:service}-${self:provider.stage}-users iamRoleStatements:
Effect: Allow
Action:
dynamodb:PutItem
dynamodb:GetItem
dynamodb:UpdateItem
dynamodb:DeleteItem
dynamodb:Scan
Resource: !GetAtt UsersTable.Arn
functions: createUser: handler: src/handlers/createUser.handler events:
http:
path: /users method: post cors: true
getUser: handler: src/handlers/getUser.handler events:
http:
path: /users/{id} method: get cors: true
listUsers: handler: src/handlers/listUsers.handler events:
http:
path: /users method: get cors: true
resources: Resources: UsersTable: Type: AWS::DynamoDB::Table Properties: TableName: ${self:provider.environment.TABLE_NAME} BillingMode: PAY_PER_REQUEST AttributeDefinitions:
AttributeName: id
AttributeType: S KeySchema:
AttributeName: id
KeyType: HASH

// src/handlers/createUser.js const AWS = require('aws-sdk'); const { v4: uuidv4 } = require('uuid');
const dynamoDb = new AWS.DynamoDB.DocumentClient(); const tableName = process.env.TABLE_NAME;
exports.handler = async (event) => { try { const requestBody = JSON.parse(event.body); const { name, email } = requestBody;
if (!name || !email) { return { statusCode: 400, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ error: 'Name and email are required' }) }; }
const userId = uuidv4(); const timestamp = new Date().getTime();
const user = { id: userId, name, email, createdAt: timestamp, updatedAt: timestamp };
await dynamoDb.put({ TableName: tableName, Item: user }).promise();
return { statusCode: 201, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(user) }; } catch (error) { console.error('Error creating user:', error); return { statusCode: 500, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ error: 'Could not create the user' }) }; } };

import * as cdk from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as lambda from 'aws-cdk-lib/aws-lambda'; import * as apigateway from 'aws-cdk-lib/aws-apigateway'; import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
export class UserApiStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props);
// DynamoDB table const userTable = new dynamodb.Table(this, 'Users', { partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING }, billingMode: dynamodb.BillingMode.PAY_PER_REQUEST, removalPolicy: cdk.RemovalPolicy.DESTROY, // NOT for production });
// Lambda functions const createUserFunction = new lambda.Function(this, 'CreateUserFunction', { runtime: lambda.Runtime.NODEJS_14_X, handler: 'createUser.handler', code: lambda.Code.fromAsset('src/handlers'), environment: { TABLE_NAME: userTable.tableName, }, });
const getUserFunction = new lambda.Function(this, 'GetUserFunction', { runtime: lambda.Runtime.NODEJS_14_X, handler: 'getUser.handler', code: lambda.Code.fromAsset('src/handlers'), environment: { TABLE_NAME: userTable.tableName, }, });
const listUsersFunction = new lambda.Function(this, 'ListUsersFunction', { runtime: lambda.Runtime.NODEJS_14_X, handler: 'listUsers.handler', code: lambda.Code.fromAsset('src/handlers'), environment: { TABLE_NAME: userTable.tableName, }, });
// Grant permissions userTable.grantReadWriteData(createUserFunction); userTable.grantReadData(getUserFunction); userTable.grantReadData(listUsersFunction);
// API Gateway const api = new apigateway.RestApi(this, 'UserApi', { restApiName: 'User Service', description: 'API for managing users', defaultCorsPreflightOptions: { allowOrigins: apigateway.Cors.ALL_ORIGINS, allowMethods: apigateway.Cors.ALL_METHODS, }, });
const users = api.root.addResource('users'); users.addMethod('POST', new apigateway.LambdaIntegration(createUserFunction)); users.addMethod('GET', new apigateway.LambdaIntegration(listUsersFunction));
const user = users.addResource('{id}'); user.addMethod('GET', new apigateway.LambdaIntegration(getUserFunction));
// Outputs new cdk.CfnOutput(this, 'ApiUrl', { value: api.url, description: 'URL of the API Gateway', }); } }