Installation

• Microsoft ODBC Driver 17 for SQL Server
  
  • need admin permission
• SQL Server Management Studio (SSMS)
  
  • need admin permission
• Microsoft SQL Server 2008 Express
  
  • need admin permission
  • issue: The specified credentials that were provided for the SQL Server service are not valid
• pyodbc
  
  • pip install pyodbc

Setup SQL Server

• Set "mixed mode authentication"
• Create a database
• Create and Configure a User in MSSQL
  
  • uncheck "User must change password at next login"
• Create a table

Connect pyodbc to SQL Server

import pyodbc
conn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER=test;DATABASE=test;UID=user;PWD=password')
cursor = conn.cursor()
for row in cursor.tables():
    print(row.table_name)

Steps

1. Create a network named "test"

   docker network create test

2. Create two containers using the network

   docker run --name c1 --network "test" --rm --entrypoint tail mongo -f
   docker run --name c2 --network "test" --rm --entrypoint tail mongo -f

3. Enter one container to ping the other and it will work

   docker exec -it c1 bash

   apt-get install iputils-ping  # install command ping

   root@79568c5ce391:/usr/src/app# ping c2
   PING c2 (172.18.0.3) 56(84) bytes of data.
   64 bytes from c2.test (172.18.0.3): icmp_seq=1 ttl=64 time=0.137 ms
   64 bytes from c2.test (172.18.0.3): icmp_seq=2 ttl=64 time=0.221 ms
   64 bytes from c2.test (172.18.0.3): icmp_seq=3 ttl=64 time=0.232 ms
   ...

Notes

Using default network or "bridge" network does not work:

docker run --name c1 --rm --entrypoint tail web_scraper:v1 -f
docker run --name c2 --rm --entrypoint tail web_scraper:v1 -f

docker run --name c1 --network "bridge" --rm --entrypoint tail web_scraper:v1 

$ docker run -p 127.0.0.1:80:8080/tcp ubuntu bash

This binds port 8080 of the container to TCP port 80 on 127.0.0.1 of the host machine. You can also specify udp and sctp ports.

$ docker run --expose 80 ubuntu bash

This exposes port 80 of the container without publishing the port to the host system’s interfaces.

Solution

Set up the same locale in both of the local laptop and remoter server:

export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8

1. Modify the EBS Volume from the console https://console.aws.amazon.com/ec2/

2. Use the lsblk command to list the block devices attached to the instance

   $ lsblk
   NAME    MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
   xvda    202:0    0   30G  0 disk
   `-xvda1 202:1    0    8G  0 part /
   loop0     7:0    0   91M  1 loop /snap/core/6405
   loop1     7:1    0 87.9M  1 loop /snap/core/5742
   loop2     7:2    0 17.9M  1 loop /snap/amazon-ssm-agent/1068
   loop3     7:3    0 16.5M  1 loop /snap/amazon-ssm-agent/784
   loop4     7:4    0   18M  1 loop /snap/amazon-ssm-agent/930

3. Use the df -h command to report the existing disk space usage on the file system

   $ sudo df -h /dev/xvd*
   Filesystem      Size  Used Avail Use% Mounted on
   udev            488M     0  488M   0% /dev
   /dev/xvda1      7.7G  7.4G  370M  96% /

4. Expand the modified partition using growpart

   $ sudo growpart /dev/xvda 1
   CHANGED: partition=1 start=2048 old: size=16775135 end=16777183 new: size=62912479,end=62914

Install

sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
sudo apt-get install certbot python-certbot-nginx 

Setup

Running this command will get a certificate for you and have Certbot edit your Nginx configuration automatically to serve it.

sudo certbot --nginx

# for a specific name
sudo certbot --nginx -d example.com

Renew

The Certbot packages on your system come with a cron job that will renew your certificates automatically before they expire.
You can test automatic renewal for your certificates by running this command:

sudo certbot renew --dry-run

Images

docker images
docker build -t image_name .
docker rmi $(docker images | grep "^<none>" | awk "{print $3}")  # remove all untagged images
docker save image_name > image_name.tar  # save image as a tar file
docker load < busybox.tar.gz  # load image

Containers

docker run -p 27017:27017 -v mongodbdata:/data/db mongo
docker ps -a
docker exec -it ubuntu_bash bash
docker rm container_name
docker rm $(docker ps -a -q)  # remove all stopped containers

Volumes

docker volume create mongodbdata
docker volume ls
docker volume inspect mongodbdata

Networks

docker network ls
docker network create network_name
docker network inspect network_name
docker network rm network_name

Azure Container Instance

docker login azure --tenant-id 8432da0f-f8af-4b02-b318-4c777cfab498
docker context create aci hpjacicontext
docker context use hpjacicontext
docker compose up

Docker compose

docker-compose up --detach --force-recreate

Sample Code: https://github.com/guangningyu/react-skeleton

1. set proxy

wget http://downloads.lightbend.com/scala/2.11.8/scala-2.11.8.rpm

3.

Create the directory structure

mkdir -p src/main/java/hello
mkdir -p src/test/java/hello

Create classes

src/main/java/hello/HelloWorld.java

package hello;
import org.joda.time.LocalTime;
public class HelloWorld {
    public static void main(String[] args) {
        LocalTime currentTime = new LocalTime();
        System.out.println("The current local time is: " + currentTime);
        Greeter greeter = new Greeter();
        System.out.println(greeter.sayHello());
    }
}

src/main/java/hello/Greeter.java

package hello;
public class Greeter {
    public String sayHello() {
        return "Hello world!";
    }
}

Write a test

src/test/java/hello/GreeterTest.java

package hello;
import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.*;
import org.junit.Test;
public class GreeterTest {
    private Greeter greeter = new Greeter();
    @Test
    public void greeterSaysHello() {
        assertThat(greeter.sayHel

• every 30 minutes

0,30 * * * * ...

• loop through object

> var _ = require('lodash');
> foo
{ a: { num: 1 }, b: { num: 2 }, c: { num: 3 } }
> _.forEach(foo, (vlu, key) => {console.log(vlu, key);})
{ num: 1 } 'a'
{ num: 2 } 'b'
{ num: 3 } 'c'
{ a: { num: 1 }, b: { num: 2 }, c: { num: 3 } }

• filter object of objects

> foo
{ a: { num: 1 }, b: { num: 2 }, c: { num: 3 } }
> _.pickBy(foo, (i) => i.num>=2)
{ b: { num: 2 }, c: { num: 3 } }

• assign default value to variable

DEFAULT=5
RESULT=${VAR:-$DEFAULT}

• trap error exit

function rollback() {
  if [[ $? -ne 0 ]]; then
    echo "rollback"
  fi
}
set -ueo pipefail
trap rollback EXIT

• if file exists

#!/bin/bash
FILE="/etc/passwd"
if [[ -f $FILE ]];then
    echo "$FILE exists"
else
    echo "$FILE doesn't exist"
fi

• if directory exists

#!/bin/bash
DIR="/var/log"
if [[ -d $DIR ]]; then
   echo "$DIR exists"
else
   echo "$DIR doesn't exist"
fi

• eval

function assert_var_exists() {
    local condition="[[ ! -n \"\${$1+set}\" ]]"
    if eval $condition; then
        echo "The variable ${1} does not exist. Exit."
        exit 1
    fi
}
function export_var() {
    assert_var_exists $1
    local var_value=$(($1))
    eval "export $1=\$var_value"
    echo "$1=$var_value"
}

• Check platform

uname -m
lsb_release

• Setting user name and email

git config --global user.name "Guangning Yu"
git config --global user.email "hi@guangningyu.com"

• Showing remotes

git remote -v

• Changing a remote’s URL

git remote set-url origin git@github.com:guangningyu flasky.git

• Pulling from remotes

git pull origin master

• Pushing to remotes

git push origin master

• Commit using default message

git commit —no-edit

• Cancel last commit

git reset HEAD~

• Undo a git add

git reset filename.txt

• Define author & committer

GIT_COMMITTER_NAME='Jane Doe' GIT_COMMITTER_EMAIL='jane@doe.com' git commit —author="John Doe <john@doe.com>" -m "This is authored by John Doe and committed by Jane Doe."

• Undo git rm

git checkout HEAD path/to/file

• Check out a remote branch

git branch -a
git checkout test_branch

• Create a new branch

git checkout -b [name_of_your_new_branch]

• Push a local branch to remote

git push -u origi

select last element in array

my_array.slice(-1)[0]

my_array.pop()