Latest Entries »

Firmware – CyanogenMod 12.1 (Lollipop) – Transformer Pad (TF701T – Macallan)

This is CyanogenMod 12.1 (Lollipop (5.1.1 – LMY49F)) for ASUS’s Transformer Pad (TF701T – Macallan).

Local: Use OpenJDK 1.7.0_111 64bit.

-sync latest changes from CyanogenMod OS repo (cm-12.1)

…..

Rom Base:
Sync’d as of 2/15.

Recovery:
CM Recovery
-Note:
You can also Use CWM 6.0.5.1 (select ‘No’ after flash to CWM’s offer to fix root).

Note:
-You must be unlocked (use ASUS’s unlock tool to perform this)
-You must be on at least 10.26.1.18 bootloader but it is reccomended to update to 11.4.1.29 (updating to ASUS’s latest 4.4.2 release will install this). It is best to update to this build (11.4.1.29) via MicroSD update method (as outlined on ASUS’s site). You can also get a CWM flash-able boot-loader package here (US only): http://droidbasement.com/asus/tf701t/stock/4.4.2-11.4.1.29/TF701T_K00C-11.4.1.29-US_BL.zip

…..

Known Issues:
-When phone audio is selected on a supported BT device; mediaserver will segfault and could cause system instability.
-Userdata encryption is currently not operational.

…..

Enjoy!

For:
TF701T

…..

Installation Instructions:
-boot in to bootloader (power and vol +/-)
-fastboot boot recovery.img (you can fastboot flash recovery recovery.img for permanence); wait a few seconds for the recovery screen.
-adb shell mount /data
-adb push cm-12.1-YYYYMMDD-UNOFFICIAL-tf701t.zip /data/media/
-take a nandroid backup (CWM only)
-flash cm-12.1-YYYYMMDD-UNOFFICIAL-tf701t.zip
-transfer and flash gapps for Android 5.1: http://download.dirtyunicorns.com/files/gapps/banks_gapps/5.x.x/ (latest for 5.1.x is 10-20-15)
-it is best to wipe when coming from stock (Note: You can upgrade from CM12)
-reboot

…..

Download:
TF701T: http://droidbasement.com/asus/tf701t/cm/12.1 (http://droidbasement NULL.com/asus/tf701t/cm/12 NULL.1)
Recovery: http://droidbasement.com/asus/tf701t/recovery/cm/12.1 (http://droidbasement NULL.com/asus/tf701t/recovery/cm/12 NULL.1)

…..

Source: https://github.com/cyanogenmod (https://github NULL.com/cyanogenmod) , https://github.com/pershoot (https://github NULL.com/pershoot)

Firmware – CyanogenMod 11 (KitKat) – Transformer Pad (TF701T – Macallan)

This is CyanogenMod 11 (KitKat (4.4.4 – KTU84Q)) for ASUS’s Transformer Pad (TF701T – Macallan).

Local: Use Open JDK 1.7.0_111 64bit.

-sync latest changes from CyanogenMod OS repo (cm-11.0)

…..

Rom Base:
Sync’d as of 2/15.

Recovery:
Built recovery is CWM 6.0.5.1 (cm-11.0).

Note:
-You must be unlocked (use ASUS’s unlock tool to perform this)
-You must be on at least 10.26.1.18 bootloader but it is reccomended to update to 11.4.1.29 (updating to ASUS’s latest 4.4.2 release will install this). It is best to update to this build (11.4.1.29) via MicroSD update method (as outlined on ASUS’s site). You can also get a CWM flash-able boot-loader package here (US only): http://droidbasement.com/asus/tf701t/stock/4.4.2-11.4.1.29/TF701T_K00C-11.4.1.29-US_BL.zip

…..

Known Issues:

…..

Enjoy!

For:
TF701T

…..

Installation Instructions:
-boot in to bootloader (power and vol +/-)
-fastboot boot recovery.img (you can fastboot flash recovery recovery.img for permanence)
-adb shell mount /data
-adb push cm-11-YYYYMMDD-UNOFFICIAL-tf701t.zip /data/media/
-take a nandroid backup
-flash lineage-11-YYYYMMDD-UNOFFICIAL-tf701t.zip
-transfer and flash gapps for CM11: http://wiki.cyanogenmod.org/w/Google_Apps
-it is best to wipe when coming from stock
-reboot

…..

Download:
TF701T: http://droidbasement.com/asus/tf701t/cm (http://droidbasement NULL.com/asus/tf701t/cm)
Recovery: http://droidbasement.com/asus/tf701t/recovery/ (http://droidbasement NULL.com/asus/tf701t/recovery)

…..

Source: https://github.com/cyanogenmod (https://github NULL.com/cyanogenmod) , https://github.com/pershoot (https://github NULL.com/pershoot)

Firmware – Asuswrt-Merlin (NG) – 384.15 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.15 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (384.15).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.15_0.trx
Download: RT-AC68U_384.15_0.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).

AWS/Terraform/Ansible/OpenShift – Provision a Lightsail instance and further configure it using Infrastructure as Code

In this article we will Provision a LightSail host with docker/docker-compose on it using Terraform and install/initialize OpenShift Origin on it using Ansible.

OpenShift (https://www NULL.openshift NULL.com/) is Red Hat’s containerization platform which utilizes Kubernetes. Origin (https://www NULL.okd NULL.io/) (what we will be working with here) is the opensource implementation of it.

We will use ‘myweb’ as an example in this article, using the same base path of ‘dev’ that was previously created, the container-admin group and using ~/.local/bin for the binaries.

Please ensure you have gone through the previous Terraform, Ansible, related preceding articles and ‘Get started with Lightsail for free’ (https://portal NULL.aws NULL.amazon NULL.com/billing/signup?client=lightsail&fid=1A3F6B376ECAC516-2C15C39C5ACECACB&redirect_url=https%3A%2F%2Flightsail NULL.aws NULL.amazon NULL.com%2Fls%2Fsignup#/start).

–>
Edit the IAM Policy “AllowLightsail”:
AWS UI Console -> Services -> Security, Identity, & Compliance -> IAM -> Policies -> AllowLightsail -> Edit Policy -> JSON ->

Append lightsail:OpenInstancePublicPorts and lightsail:CloseInstancePublicPorts after lightsail:ReleaseStaticIp.

It will look like this:

                  "lightsail:ReleaseStaticIp",
                  "lightsail:OpenInstancePublicPorts",
                  "lightsail:CloseInstancePublicPorts"

Review Policy -> Save Changes

Go in to the dev directory/link located within your home directory:

$ cd ~/dev

Upgrade the AWS CLI on your host:

$ pip3 install awscli --upgrade --user && chmod 754 ~/.local/bin/aws

Grab the latest version of Terraform:

$ wget https://releases.hashicorp.com/terraform/0.12.20/terraform_0.12.20_linux_amd64.zip

Unzip it to ~/.local/bin and set permissions accordingly on it:

$ unzip terraform_0.12.20_linux_amd64.zip -d ~/.local/bin && chmod 754 ~/.local/bin/terraform

Change to the myweb directory inside terraform:

$ cd terraform/myweb

Upgrade our code to 12.20 (type yes and enter when prompted):

$ terraform 0.12upgrade

Change our instance from a micro to a medium so it will have sufficient resources to run OpenShift Origin and related:

$ sed -i s:micro_2_0:medium_2_0: lightsail.tf

Output the Public IP of the Provisioned host (along with connection parameters and variables) in to a file which we will feed in to an Ansible playbook run:

$ cat << 'EOF' >> output.tf
>
> resource "local_file" "hosts" {
>   content              = "[vps]\n${aws_lightsail_static_ip.myweb.ip_address} ansible_connection=ssh ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/myweb instance=${aws_lightsail_instance.myweb.name}"
>   filename             = "${path.module}/../../ansible/hosts"
>   directory_permission = 0754
>   file_permission      = 0664
> }
> EOF 

Amend an item from the user_data script:

$ sed -i 's:sudo apt-key add -:apt-key add -:' scripts/install.sh

Initialize the directory/refresh module(s):

$ terraform init

Run a dry-run to see what will occur:

$ terraform plan

Provision:

$ terraform apply -auto-approve

Create a work folder for an Ansible playbook:

$ cd ../../ansible
$ mkdir -p openshift/scripts && cd openshift

Create an Ansible playbook which will install/initialize OpenShift Origin on our provisioned host:

$ cat << 'EOF' > openshift.yml 
> # Install, initialize OpenShift Origin and create a destroy routine for it
> ---
> - hosts: vps
>   connection: local
>
>   vars:
>     openshift_directory: /home/ubuntu/.local/etc/openshift
>
>   tasks:
>     - name: Discover Services
>       service_facts:
>
>     - name: Check if openshift directory exists
>       stat:
>         path: "{{ openshift_directory }}"
>       register: openshift_dir
>
>     - name: Open Firewall Ports
>       delegate_to: localhost
>       command: bash -c './scripts/firewall.sh open {{ hostvars[groups['vps'][0]].instance }}'
>       when:
>         - "'docker' in services"
>         - openshift_dir.stat.exists == False
>  
>     - name: Copy and Run install
>       environment:
>         PATH: "{{ ansible_env.PATH}}:{{ openshift_directory }}/../../bin"
>       args:
>         executable: /bin/bash
>       script: "./scripts/install.sh {{ ansible_ssh_host }}"
>       when:
>         - "'docker' in services"
>         - openshift_dir.stat.exists == False
>
>     - debug: msg="Please install docker to proceed."
>       when: "'docker' not in services"
>
>     - debug: msg="Install script has already been completed.  Run this playbook with the destroy tag, then run once again normally to re-intialize openshift."
>       when: openshift_dir.stat.exists == True
>
>     - name: Destroy
>       become: yes
>       environment:
>         PATH: "{{ ansible_env.PATH}}:{{ openshift_directory }}/../../bin"
>       args:
>         executable: /bin/bash
>       shell: "cd {{ openshift_directory }} && oc cluster down && cd ../ && rm -r {{ openshift_directory }}/../../../.kube {{ openshift_directory }}"
>       tags: [ 'never', 'destroy' ]
>
>     - name: Close Firewall Ports
>       delegate_to: localhost
>       command: bash -c './scripts/firewall.sh close {{ hostvars[groups['vps'][0]].instance }}'
>       tags: [ 'never', 'destroy' ]
> EOF    

Create a shell script which will pull the latest release of client tools from GitHub, place the needed binaries in ~/.local/bin, set insecure registry on Docker and initialize:

$ cat << 'EOF' > scripts/install.sh
> #!/bin/bash
> [[ -z $* ]] && { echo "Please specify a Public IP or Host/Domain name." && exit 1; }
> # Fetch and Install
> file_url="$(curl -sL https://github.com/openshift/origin/releases/latest | grep "download.*client.*linux-64" | cut -f2 -d\" | sed 's/^/https:\/\/github.com/')"
> [[ -z $file_url ]] && { echo "The URL could not be obtained.  Please try again shortly." && exit 1; }
> file_name="$(echo $file_url | cut -f9 -d/)"
> if [[ ! -f $file_name ]]; then
>         curl -sL $file_url --output $file_name
>         folder_name="$(tar ztf $file_name 2>/dev/null | head -1 | sed s:/.*::)"
>         [[ -z $folder_name ]] && { echo "The archive could not be read.  Please try again." && rm -f $file_name && exit 1; }
>         tar zxf $file_name
>         mv $folder_name/oc $folder_name/kubectl $HOME/.local/bin && rm -r $folder_name
>         chmod 754 $HOME/.local/bin/oc $HOME/.local/bin/kubectl
> fi
> # Docker insecure
> [[ $(grep insecure /etc/docker/daemon.json &>/dev/null; echo $?) -eq 2 ]] && redirect=">"
> [[ $(grep insecure /etc/docker/daemon.json &>/dev/null; echo $?) -eq 1 ]] && redirect=">>"
> [[ $(grep insecure /etc/docker/daemon.json &>/dev/null; echo $?) -eq 0 ]] || { sudo bash -c "cat << 'EOF' $redirect /etc/docker/daemon.json
> {
>         \"insecure-registries\" : [ \"172.30.0.0/16\" ]
> }
> EOF" && sudo systemctl restart docker; }
> # OpenShift Origin up
> [[ ! -d $HOME/.local/etc/openshift ]] && { mkdir -p $HOME/.local/etc/openshift && cd $HOME/.local/etc/openshift; } || { cd $HOME/.local/etc/openshift && oc cluster down; }
> oc cluster up --public-hostname=$1
>
> exit 0
> EOF 

The Lightsail firewall functionality is currently being implemented in Terraform and is not available in Ansible. In the interim, we will create a shell script to open and close ports needed by OpenShift Origin (using the AWS CLI). This script will be run locally via the Playbook during the create and destroy routines:

$ cat << 'EOF' > scripts/firewall.sh && chmod 754 scripts/firewall.sh
> #!/bin/bash
> #
> openshift_ports="53/UDP 443/TCP 1936/TCP 4001/TCP 7001/TCP 8053/UDP 8443/TCP 10250_10259/TCP"
> #
> [[ -z $* || $(echo $* | xargs -n1 | wc -l) -ne 2 || ! ($* =~ $(echo '\<open\>') || $* =~ $(echo '\<close\>')) ]] && { echo "Please pass in the desired action [ open, close ] and instance [ site_myweb ]." && exit 2; }
> #
> instance="$(echo $* | xargs -n1 | sed '/\<open\>/d; /\<close\>/d')"
> [[ -z $instance ]] && { echo "Please double-check the passed in instance." && exit 1; }
> action="$(echo $* | xargs -n1 | grep -v $instance)"
> #
> for port in $openshift_ports; do
>         aws lightsail $action-instance-public-ports --instance $instance --port-info fromPort=$(echo $port | cut -f1 -d_ | cut -f1  -d/),protocol=$(echo $port | cut -f2 -d/),toPort=$(echo $port | cut -f2 -d_ | cut -f1 -d/)
> done
> #
>
> exit 0
> EOF 

Run the Ansible playbook after a few minutes (accept the host key by typing yes and hitting enter when prompted):

$ ansible-playbook -i ../hosts openshift.yml

After a short while, log on to the instance:

$ ssh -i ~/.ssh/myweb ubuntu@<The value of static_public_ip that was reported.  One can also use 'terraform output static_public_ip' to print it again.>

To get an overview of the current project with any identified issues:

$ oc status --suggest

Log on as Admin via CMD Line and switch to the default project:

$ oc login -u system:admin -n default

Logout of the session:

$ oc logout

Please see the Command-Line Walkthrough (https://docs NULL.openshift NULL.com/enterprise/3 NULL.2/getting_started/developers_cli NULL.html).

Logout from the host:

$ logout

Log on as Admin via Web Browser (replace <PUBLIC_IP>):

https://<PUBLIC_IP>:8443/console (You will get a Certificate/Site warning due to a mismatch).

Please see the Web Console Walkthrough (https://docs NULL.openshift NULL.com/enterprise/3 NULL.2/getting_started/developers_console NULL.html).

To shut down the OpenShift Origin cluster, destroy the working folder and start anew (you can re-run the playbook normally to reinitialize):

$ ansible-playbook -i ../hosts openshift.yml --tags "destroy"

Tear down what was created by first performing a dry-run to see what will occur:

$ cd ../../terraform/myweb && terraform plan -destroy 

Tear down the instance:

$ terraform destroy -auto-approve

<–

References:
how-to-install-openshift-origin-on-ubuntu-18-04 (https://www NULL.techrepublic NULL.com/article/how-to-install-openshift-origin-on-ubuntu-18-04)

Source:
ansible_openshift (https://github NULL.com/pershoot/ansible_openshift)

Firmware – Asuswrt-Merlin (NG) – 384.15_beta1 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.15_beta1 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (384.15_beta1).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.15_beta1.trx
Download: RT-AC68U_384.15_beta1.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).

Firmware – Asuswrt-Merlin (NG) – 384.14_2 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.14_2 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (384.14_2).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.14_2.trx
Download: RT-AC68U_384.14_2.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).

AWS/Ansible – Provision a Lightsail instance using Infrastructure as Code

Note: This article has been duplicated from the previous article which uses Terraform and has been modified for Ansible.

AWS has introduced Lightsail (https://aws NULL.amazon NULL.com/lightsail/) to compete with Digital Ocean, Linode, etc. for an inexpensive VPS (Virtual Private Server) offering.

In this article we will use Ansible (https://www NULL.ansible NULL.com/) (Infrastructure as Code) to swiftly bring up an AWS Lightsail instance in us-east-1 on a dynamic IP and install docker/docker-compose on it.

We will use ‘myweb’ as an example in this article, using the same base path of ‘dev’ that was previously created, the container-admin group and using ~/.local/bin|lib for the binaries/libraries.

Please use ‘Get started with Lightsail for free’ (https://portal NULL.aws NULL.amazon NULL.com/billing/signup?client=lightsail&fid=1A3F6B376ECAC516-2C15C39C5ACECACB&redirect_url=https%3A%2F%2Flightsail NULL.aws NULL.amazon NULL.com%2Fls%2Fsignup#/start) prior to commencing with this article.

–>
Go in to the dev directory/link located within your home directory:

$ cd ~/dev

Upgrade the AWS CLI on your host:

$ pip3 install awscli --upgrade --user && chmod 754 ~/.local/bin/aws

Install/Upgrade Ansible:

$ pip3 install ansible --upgrade --user && chmod 754 ~/.local/bin/ansible ~/.local/bin/ansible-playbook

Install/Upgrade Boto3:

$ pip3 install boto3 --upgrade --user

Create a work folder and change in to it:

$ mkdir -p ansible/myweb/scripts && cd ansible/myweb

Add an IAM Policy to the container-admin group so it will have access to the Lightsail API:
AWS UI Console -> Services -> Security, Identity, & Compliance -> IAM -> Policies -> Create Policy -> JSON (replace <AWS ACCOUNT ID> in the Resource arn with your Account’s ID (shown under the top right drop-down (of your name) within the My Account page next to the Account Id: under Account Settings)):

{
     "Version": "2012-10-17",
     "Statement": [
         {
             "Effect": "Allow",
             "Action": [
                 "lightsail:GetRelationalDatabaseEvents",
                 "lightsail:GetActiveNames",
                 "lightsail:GetOperations",
                 "lightsail:GetBlueprints",
                 "lightsail:GetRelationalDatabaseMasterUserPassword",
                 "lightsail:ExportSnapshot",
                 "lightsail:UnpeerVpc",
                 "lightsail:GetRelationalDatabaseLogEvents",
                 "lightsail:GetRelationalDatabaseBlueprints",
                 "lightsail:GetRelationalDatabaseBundles",
                 "lightsail:CopySnapshot",
                 "lightsail:GetRelationalDatabaseMetricData",
                 "lightsail:PeerVpc",
                 "lightsail:IsVpcPeered",
                 "lightsail:UpdateRelationalDatabaseParameters",
                 "lightsail:GetRegions",
                 "lightsail:GetOperation",
                 "lightsail:GetDisks",
                 "lightsail:GetRelationalDatabaseParameters",
                 "lightsail:GetBundles",
                 "lightsail:GetRelationalDatabaseLogStreams",
                 "lightsail:CreateKeyPair",
                 "lightsail:ImportKeyPair",
                 "lightsail:DeleteKeyPair",
                 "lightsail:GetInstance",
                 "lightsail:CreateInstances",
                 "lightsail:DeleteInstance",
                 "lightsail:GetDomains",
                 "lightsail:GetDomain",
                 "lightsail:CreateDomain",
                 "lightsail:DeleteDomain",
                 "lightsail:GetStaticIp",
                 "lightsail:AllocateStaticIp",
                 "lightsail:AttachStaticIp",
                 "lightsail:DetachStaticIp",
                 "lightsail:ReleaseStaticIp"
             ],
             "Resource": "*"         
         },
         {
             "Effect": "Allow",
             "Action": "lightsail:",
             "Resource": [
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:StaticIp/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:ExportSnapshotRecord/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:Instance/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:CloudFormationStackRecord/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:RelationalDatabaseSnapshot/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:RelationalDatabase/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:InstanceSnapshot/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:Domain/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:LoadBalancer/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:KeyPair/*",
                 "arn:aws:lightsail::<AWS ACCOUNT ID>:Disk/*"
             ]
         }
     ]
 }

Review Policy ->

Name: AllowLightsail
Description: Allow access to Lightsail.

Create Policy.

Groups -> container-admin -> Attach Policy -> Search for AllowLightsail -> Attach Policy.

Generate an SSH Key Pair (no password) and restrict permissions on it:

$ ssh-keygen -q -t rsa -b 2048 -N '' -f ~/.ssh/myweb && chmod 400 ~/.ssh/myweb

Import the public key to Lightsail:

$ aws lightsail import-key-pair --key-pair-name myweb --public-key-base64 file://~/.ssh/myweb.pub

Create a hosts file and specify localhost:

$ cat << 'EOF' > hosts
> [local]
> localhost
> EOF

Create a micro instance based off of Ubuntu 18_04 and reference an extraneous file for user_data (run once script on Virtual Machine boot):

$ cat << 'EOF' > lightsail.yml
> # Create a new AWS Lightsail instance, register the instance details and add a way to destroy it
> ---
> - hosts: local
>   connection: local
>
>   tasks:
>     - lightsail:
>         state: present
>         name: myweb.com
>         region: us-east-1
>         zone: us-east-1a
>         blueprint_id: ubuntu_18_04
>         bundle_id: micro_2_0
>         key_pair_name: myweb
>         user_data: "{{ lookup('file', './scripts/install.sh') }}"
>         wait_timeout: 500
>       register: myweb
>
>     - debug: msg="Public IP is {{ myweb.instance.public_ip_address }} for {{ myweb.instance.name }}"
>       when: myweb.instance.public_ip_address is defined
>
>     - debug: msg="Run this playbook for {{ myweb.instance.name }} shortly to list the Public IP."
>       when: myweb.instance.public_ip_address is not defined
>
>     - lightsail:
>         state: absent
>         name: myweb.com
>         region: us-east-1
>       tags: [ 'never', 'destroy' ]
> EOF

Create the shell script for user_data:

$ cat << 'EOF' > scripts/install.sh
> #!/bin/bash
>
> MY_HOME="/home/ubuntu"
> export DEBIAN_FRONTEND=noninteractive
>
> # Install prereqs
> apt update
> apt install -y python3-pip apt-transport-https ca-certificates curl software-properties-common
> # Install docker
> curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
> add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
> apt update
> apt install -y docker-ce
> # Install docker-compose
> su ubuntu -c "mkdir -p $MY_HOME/.local/bin"
> su ubuntu -c "pip3 install docker-compose --upgrade --user && chmod 754 $MY_HOME/.local/bin/docker-compose"
> usermod -aG docker ubuntu
> # Add PATH
> printf "\nexport PATH=\$PATH:$MY_HOME/.local/bin\n" >> $MY_HOME/.bashrc
>
> exit 0
> EOF

Run the playbook:

$ ansible-playbook -i hosts lightsail.yml

Log on to the instance (up to ~30 seconds may be needed for the attachment of the dynamic IP to the instance):

$ ssh -i ~/.ssh/myweb ubuntu@<The value of public_ip_address that was reported.  One can also re-run the playbook to print it again.>

Type yes and hit enter to accept.

On the host (a short while is needed for the run-once script to complete):

$ docker --version
$ docker-compose --version
$ logout

Tear down the instance:

$ ansible-playbook -i hosts lightsail.yml --tags "destroy"

<–

References:

Source:
ansible_myweb (https://github NULL.com/pershoot/ansible_myweb)

Firmware – Asuswrt-Merlin (NG) – 384.14 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.14 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (master).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.14_0.trx
Download: RT-AC68U_384.14_0.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).

Firmware – Asuswrt-Merlin (NG) – 384.14_beta3 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.14_beta3 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (master).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.14_beta3.trx
Download: RT-AC68U_384.14_beta3.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).

Firmware – Asuswrt-Merlin (NG) – 384.14_beta2 – RT-AC68

This is Merlin’s Asuswrt (NG) 384.14_beta2 for the ASUS RT-AC68U/R.

-sync latest changes from RMerlin (master).

—–

Download (ASUS RT-AC68U/R):
RT-AC68U_384.14_beta2.trx
Download: RT-AC68U_384.14_beta2.trx (http://droidbasement NULL.com/asus/rt-ac68/merlin/)

—–

Source:
https://github.com/pershoot/asuswrt-merlin.ng (https://github NULL.com/pershoot/asuswrt-merlin NULL.ng)
https://github.com/RMerl/asuswrt-merlin.ng (https://github NULL.com/RMerl/asuswrt-merlin NULL.ng)

——–

Installation instructions:

-Flash the .trx through the UI
-After it is completed and you are returned back to the UI, wait a short while (~30 seconds) then power cycle the router (with the on/off button).