openvidu/openvidu-server/deployments/enterprise/aws/cfn-crete-ov-aws-asg-ami.yaml.template

---
AWSTemplateFormatVersion: 2010-09-09
Description: Openvidu Server Pro CloudFormation AMI template.

Mappings:
  AMIMAP:
    eu-west-1:
      AMI: AMIEUWEST1
    us-east-1:
      AMI: AMIUSEAST1

Resources:
  OpenviduServerPro:
    Type: 'AWS::EC2::Instance'
    Metadata:
      Comment: "Install OpenVidu Server Pro AWS ASG"
      AWS::CloudFormation::Init:
        config:
          files:
            "/etc/cfn/cfn-hup.conf":
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
              mode: "000400"
              owner: "root"
              group: "root"
            "/etc/cfn/hooks.d/cfn-auto-reloader.conf":
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.OpenviduServerPro.Metadata.AWS::CloudFormation::Init
                action=/usr/local/bin/cfn-init -v --stack ${AWS::StackName} --resource OpenviduServerPro --region ${AWS::Region}
              mode: "000400"
              owner: "root"
              group: "root"
            "/usr/local/bin/installDockerAndDockerCompose.sh":
              content: |
                #!/bin/bash
                set -eu -o pipefail

                # Install Docker
                apt-get update && apt-get install -y \
                    apt-transport-https \
                    ca-certificates \
                    curl \
                    gnupg-agent \
                    software-properties-common

                curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
                echo \
                  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
                  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

                apt-get update && apt-get install -y \
                  docker-ce \
                  docker-ce-cli \
                  containerd.io

                # Install docker-compose v2
                LATEST_DOCKER_COMPOSE_VERSION=$(curl -sSL https://api.github.com/repos/docker/compose/tags | grep name | head -n1 | cut -d'"' -f4)

                OS="$(uname -s | awk '{print tolower($0)}')"
                ARCH="$(uname -m)"

                mkdir -p /usr/local/lib/docker/cli-plugins
                rm -f /usr/local/lib/docker/cli-plugins/docker-compose
                curl -SL "https://github.com/docker/compose/releases/download/${LATEST_DOCKER_COMPOSE_VERSION}/docker-compose-${OS}-${ARCH}" \
                  -o /usr/local/lib/docker/cli-plugins/docker-compose
                chmod +x /usr/local/lib/docker/cli-plugins/docker-compose
                ln -s /usr/local/lib/docker/cli-plugins/docker-compose /usr/local/bin

              mode: "000755"
              owner: "root"
              group: "root"
            "/usr/local/bin/installOpenviduServerPRO.sh":
              content: |
                #!/bin/bash
                set -eu -o pipefail

                # Install openvidu-pro
                cd /opt
                curl https://s3-eu-west-1.amazonaws.com/aws.openvidu.io/install_openvidu_enterprise_master_node_OPENVIDU_VERSION.sh | bash

                if [[ USE_MASTER_DOCKER_IMAGES == "true" ]]; then
                  pushd openvidu

                  # docker-compose.yml replace with master version
                  IMAGES="$(cat docker-compose.yml | grep 'image: openvidu/' | cut -d':' -f2 | sed -e 's/^[[:space:]]*//')"
                  for IMG in $IMAGES
                  do
                    sed -i "s|image: $IMG:.*|image: $IMG:master-v2|g" docker-compose.yml
                  done

                  # docker-compose.override.yml replace with master version
                  if [[ -f docker-compose.override.yml ]]; then
                    IMAGES="$(cat docker-compose.override.yml | grep 'image: openvidu/' | cut -d':' -f2 | sed -e 's/^[[:space:]]*//')"
                    for IMG in $IMAGES
                    do
                      sed -i "s|image: $IMG:.*|image: $IMG:master-v2|g" docker-compose.override.yml
                    done
                  fi

                  # openvidu-recording replace with master version
                  echo "OPENVIDU_RECORDING_VERSION=OPENVIDU_RECORDING_DOCKER_TAG" >> /opt/openvidu/.env

                  popd
                fi
              mode: "000755"
              owner: "root"
              group: "root"
            "/usr/local/bin/getDockerImages.sh":
              content: !Sub |
                #!/bin/bash
                set -eu -o pipefail

                # AWS cli
                docker pull amazon/aws-cli:AWS_CLI_DOCKER_TAG

                # Openvidu recording
                docker pull openvidu/openvidu-recording:OPENVIDU_RECORDING_DOCKER_TAG

                # Openvidu PRO images
                cd /opt/openvidu
                docker-compose pull
              mode: "000755"
              owner: "root"
              group: "root"
            "/usr/local/bin/openvidu-init.sh":
              content: |
                #!/bin/bash -x

                WORKINGDIR=/opt/openvidu
                TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
                ASG_DATA=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/user-data)
                AWS_AVAIL_ZONE=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/placement/availability-zone)
                AWS_REGION="`echo \"$AWS_AVAIL_ZONE\" | sed 's/[a-z]$//'`"
                AWS_INSTANCE_ID=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/instance-id)

                # S3 bucket
                OPENVIDU_PRO_CONFIG_S3_BUCKET=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_CONFIG_S3_BUCKET=).+?(?=\s*(\||$))" | cut -d"=" -f2)

                if [[ ! -f "/var/lib/openvidu/.openvidu-first-run" ]]; then
                  echo "First run of OpenVidu in this machine"
                  mkdir -p /var/lib/openvidu
                  touch "/var/lib/openvidu/.openvidu-first-run"

                  # Domain
                  DOMAIN_OR_PUBLIC_IP=$(echo ${ASG_DATA} | grep -Po "(DOMAIN_OR_PUBLIC_IP=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  sed -i "s|DOMAIN_OR_PUBLIC_IP=|DOMAIN_OR_PUBLIC_IP=${DOMAIN_OR_PUBLIC_IP}|" $WORKINGDIR/.env

                  # Pro License
                  OPENVIDU_PRO_LICENSE=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_LICENSE=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  sed -i "s|OPENVIDU_PRO_LICENSE=|OPENVIDU_PRO_LICENSE=${OPENVIDU_PRO_LICENSE}|" $WORKINGDIR/.env

                  # Secret
                  OPENVIDU_SECRET=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_SECRET=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  sed -i "s|OPENVIDU_SECRET=|OPENVIDU_SECRET=${OPENVIDU_SECRET}|" $WORKINGDIR/.env

                  # Media Server
                  OPENVIDU_ENTERPRISE_MEDIA_SERVER=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_ENTERPRISE_MEDIA_SERVER=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  sed -i "s|OPENVIDU_ENTERPRISE_MEDIA_SERVER=|OPENVIDU_ENTERPRISE_MEDIA_SERVER=${OPENVIDU_ENTERPRISE_MEDIA_SERVER}|" $WORKINGDIR/.env

                  # ElasticSearch and Kibana
                  OPENVIDU_PRO_ELASTICSEARCH=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_ELASTICSEARCH=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  OPENVIDU_PRO_ELASTICSEARCH_HOST=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_ELASTICSEARCH_HOST=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  OPENVIDU_PRO_KIBANA_HOST=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_KIBANA_HOST=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  ELASTICSEARCH_USERNAME=$(echo ${ASG_DATA} | grep -Po "(ELASTICSEARCH_USERNAME=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  ELASTICSEARCH_PASSWORD=$(echo ${ASG_DATA} | grep -Po "(ELASTICSEARCH_PASSWORD=).+?(?=\s*(\||$))" | cut -d"=" -f2)

                  OPENVIDU_PRO_CLUSTER_ID=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_CLUSTER_ID=).+?(?=\s*(\||$))" | cut -d"=" -f2)

                  if [[ "${OPENVIDU_PRO_ELASTICSEARCH}" == "true" ]]; then
                    sed -i "s|#OPENVIDU_PRO_ELASTICSEARCH_HOST=|OPENVIDU_PRO_ELASTICSEARCH_HOST=${OPENVIDU_PRO_ELASTICSEARCH_HOST}|" $WORKINGDIR/.env
                    sed -i "s|#OPENVIDU_PRO_KIBANA_HOST=|OPENVIDU_PRO_KIBANA_HOST=${OPENVIDU_PRO_KIBANA_HOST}|" $WORKINGDIR/.env
                    sed -i "s|ELASTICSEARCH_USERNAME=elasticadmin|ELASTICSEARCH_USERNAME=${ELASTICSEARCH_USERNAME}|" $WORKINGDIR/.env
                    sed -i "s|ELASTICSEARCH_PASSWORD=|ELASTICSEARCH_PASSWORD=${ELASTICSEARCH_PASSWORD}|" $WORKINGDIR/.env
                  else
                    sed -i "s|OPENVIDU_PRO_ELASTICSEARCH=true|OPENVIDU_PRO_ELASTICSEARCH=false|" $WORKINGDIR/.env
                  fi

                  sed -i "s|# OPENVIDU_PRO_CLUSTER_ID=|OPENVIDU_PRO_CLUSTER_ID=${OPENVIDU_PRO_CLUSTER_ID}|" $WORKINGDIR/.env

                  sed -i "s|OPENVIDU_PRO_CLUSTER_ENVIRONMENT=on_premise|OPENVIDU_PRO_CLUSTER_ENVIRONMENT=aws|" $WORKINGDIR/.env

                  # S3 Bucket
                  OPENVIDU_RECORDING=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_RECORDING=).+?(?=\s*(\||$))" | cut -d"=" -f2)

                  # Recording
                  if [[ "${OPENVIDU_RECORDING}" == "true" ]]; then
                    sed -i "s|OPENVIDU_RECORDING=false|OPENVIDU_RECORDING=true|" $WORKINGDIR/.env
                  fi
                  sed -i "s|#OPENVIDU_PRO_RECORDING_STORAGE=|OPENVIDU_PRO_RECORDING_STORAGE=s3|" $WORKINGDIR/.env
                  sed -i "s|#OPENVIDU_PRO_AWS_S3_BUCKET=|OPENVIDU_PRO_AWS_S3_BUCKET=${OPENVIDU_PRO_CONFIG_S3_BUCKET}/recordings|" $WORKINGDIR/.env

                  # Deploy Coturn in media nodes
                  OPENVIDU_PRO_COTURN_IN_MEDIA_NODES=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_PRO_COTURN_IN_MEDIA_NODES=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  if [ "${OPENVIDU_PRO_COTURN_IN_MEDIA_NODES}" == "true" ]; then
                    sed -i "s|OPENVIDU_PRO_COTURN_IN_MEDIA_NODES=false|OPENVIDU_PRO_COTURN_IN_MEDIA_NODES=true|" $WORKINGDIR/.env
                  fi

                  # AWS Instance ID and region
                  sed -i "s|#AWS_INSTANCE_ID=|AWS_INSTANCE_ID=${AWS_INSTANCE_ID}|" $WORKINGDIR/.env

                  # AWS ASG
                  RM_REDIS_IP=$(echo ${ASG_DATA} | grep -Po "(RM_REDIS_IP=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  RM_REDIS_PORT=$(echo ${ASG_DATA} | grep -Po "(RM_REDIS_PORT=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  RM_SQS_QUEUE=$(echo ${ASG_DATA} | grep -Po "(RM_SQS_QUEUE=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  RM_CLOUDFORMATION_ARN=$(echo ${ASG_DATA} | grep -Po "(RM_CLOUDFORMATION_ARN=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  # Autoscaling group names
                  RM_MEDIA_NODES_AUTOSCALING_GROUP_NAME=$(echo ${ASG_DATA} | grep -Po "(RM_MEDIA_NODES_AUTOSCALING_GROUP_NAME=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  RM_MASTER_NODES_AUTOSCALING_GROUP_NAME=$(echo ${ASG_DATA} | grep -Po "(RM_MASTER_NODES_AUTOSCALING_GROUP_NAME=).+?(?=\s*(\||$))" | cut -d"=" -f2)

                  sed -i "s|RM_REDIS_IP=|RM_REDIS_IP=${RM_REDIS_IP}|" $WORKINGDIR/.env
                  sed -i "s|RM_REDIS_PORT=|RM_REDIS_PORT=${RM_REDIS_PORT}|" $WORKINGDIR/.env
                  sed -i "s|RM_SQS_QUEUE=|RM_SQS_QUEUE=${RM_SQS_QUEUE}|" $WORKINGDIR/.env
                  sed -i "s|RM_CLOUDFORMATION_ARN=|RM_CLOUDFORMATION_ARN=${RM_CLOUDFORMATION_ARN}|" $WORKINGDIR/.env
                  sed -i "s|RM_S3_CONFIGURATION_BUCKET=|RM_S3_CONFIGURATION_BUCKET=${OPENVIDU_PRO_CONFIG_S3_BUCKET}|" $WORKINGDIR/.env
                  sed -i "s|RM_S3_CONFIGURATION_BUCKET_REGION=|RM_S3_CONFIGURATION_BUCKET_REGION=${AWS_REGION}|" $WORKINGDIR/.env
                  sed -i "s|RM_MEDIA_NODES_AUTOSCALING_GROUP_NAME=|RM_MEDIA_NODES_AUTOSCALING_GROUP_NAME=${RM_MEDIA_NODES_AUTOSCALING_GROUP_NAME}|" $WORKINGDIR/.env
                  sed -i "s|RM_MASTER_NODES_AUTOSCALING_GROUP_NAME=|RM_MASTER_NODES_AUTOSCALING_GROUP_NAME=${RM_MASTER_NODES_AUTOSCALING_GROUP_NAME}|" $WORKINGDIR/.env

                  # Autorestart on .env changes in S3
                  OPENVIDU_ENTERPRISE_S3_CONFIG_AUTORESTART=$(echo ${ASG_DATA} | grep -Po "(OPENVIDU_ENTERPRISE_S3_CONFIG_AUTORESTART=).+?(?=\s*(\||$))" | cut -d"=" -f2)
                  if [[ "${OPENVIDU_ENTERPRISE_S3_CONFIG_AUTORESTART}" == "true" ]]; then
                    echo "OPENVIDU_ENTERPRISE_S3_CONFIG_AUTORESTART=true" >> $WORKINGDIR/.env
                  else
                    echo "OPENVIDU_ENTERPRISE_S3_CONFIG_AUTORESTART=false" >> $WORKINGDIR/.env
                  fi

                  # Random Turn shared secret
                  echo "COTURN_SHARED_SECRET_KEY=$(openssl rand -hex 16)" >> $WORKINGDIR/.env

                  # End with newline
                  echo "" >> $WORKINGDIR/.env
                fi

                # Stop openvidu
                pushd "${WORKINGDIR}"
                ./openvidu stop
                ./openvidu start
                popd

              mode: "000755"
              owner: "root"
              group: "root"
    Properties:
      ImageId: !FindInMap [AMIMAP, !Ref 'AWS::Region', AMI]
      InstanceType: "t2.2xlarge"
      KeyName: AWS_KEY_NAME
      Tags:
        - Key: Name
          Value: !Ref AWS::StackName
      BlockDeviceMappings:
        - DeviceName: /dev/sda1
          Ebs:
            VolumeType: gp3
            DeleteOnTermination: true
            VolumeSize: 10
      UserData:
        "Fn::Base64":
          !Sub |
            #!/bin/bash -x
            set -eu -o pipefail
            apt-get update && apt-get install -y \
                python3-pip \
                ec2-instance-connect
            pip3 install https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-py3-latest.tar.gz

            cfn-init --region ${AWS::Region} --stack ${AWS::StackId} --resource OpenviduServerPro

            /usr/local/bin/installDockerAndDockerCompose.sh || { echo "[Openvidu] error installing docker and compose"; exit 1; }

            /usr/local/bin/installOpenviduServerPRO.sh || { echo "[Openvidu] error installing Openvidu Server PRO"; exit 1; }

            /usr/local/bin/getDockerImages.sh || { echo "[Openvidu] error getting docker images"; exit 1; }

            # Launch on reboot
            echo "@reboot /usr/local/bin/openvidu-init.sh >> /var/log/openvidu-init.log 2>&1" | crontab

            # sending the finish call
            /usr/local/bin/cfn-signal -e $? --stack ${AWS::StackId} --resource WaitCondition --region ${AWS::Region}

            # Cleaning the house
            shred -u /var/log/cloud-init-output.log
            shred -u /etc/ssh/*_key /etc/ssh/*_key.pub
            shred -u /usr/local/bin/installDockerAndDockerCompose.sh
            shred -u /usr/local/bin/installOpenviduServerPRO.sh
            shred -u /usr/local/bin/getDockerImages.sh
            shred -u /usr/local/bin/installDependencies.sh
            find /var/lib/cloud/instances/$(curl http://169.254.169.254/latest/meta-data/instance-id) -type f | xargs shred -u
            rm -rf /var/lib/cloud/instances/$(curl http://169.254.169.254/latest/meta-data/instance-id)

  WaitCondition:
    Type: AWS::CloudFormation::WaitCondition
    CreationPolicy:
      ResourceSignal:
        Timeout: PT20M
        Count: 1