DevMemo – cheatsheet

Cheatsheets: Cheatsheets

Fri, 20 Jan 2023 22:42:06 -0800

Cheatsheets: Ansible Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Install

# Install ansible (for user).
python3 -m pip install --user ansible

# Upgrade ansible (for user).
python3 -m pip install --upgrade --user ansible

# Display ansible core version.
ansible --version

# Display ansible version.
python3 -m pip show ansible

# Unsnstall ansible.
python3 -m pip uninstall ansible

Inventory

Host.ini

# Hosts in group 'all'.
host1
host2

# Hosts in a group.
[group-name]
host1
host2

# Hosts in a group with variables defined.
[group-name]
host1 <var_1>=<value_1> <var_2>=<value_2> ... <var_n>=<value_n>
host2 <var_1>=<value_1> <var_2>=<value_2> ... <var_n>=<value_n>

Host Variables

Variable Name	Description
`ansible_host`	The name or the ip of the host to connect to. If none, the alias will be used.
`ansible_port`	The port to connect, if not defined, port 12 will used.
`ansible_user`	The user to use when connecting to the host
`ansible_password`	The password to use to authenticate to the host
`ansible_ssh_private_key_file`	Private key file used by ssh.
`ansible_ssh_common_args`	This setting is always appended to the default command line for sftp, scp, and ssh.
`ansible_sftp_extra_args`	This setting is always appended to the default sftp command line.
`ansible_scp_extra_args`	This setting is always appended to the default scp command line.
`ansible_ssh_extra_args`	This setting is always appended to the default ssh command line.
`ansible_ssh_pipelining`	Determines whether or not to use SSH pipelining. This can override the pipelining setting in ansible.cfg.
`ansible_ssh_executable`	This setting overrides the default behavior to use the system ssh. This can override the `ssh_executable` setting in ansible.cfg.
`ansible_become`	Equivalent to `ansible_sudo or ansible_su`, allows to force privilege escalation
`ansible_become_method`	Allows to set privilege escalation method
`ansible_become_user`	Equivalent to `ansible_sudo_user` or `ansible_su_user`, allows to set the user you become through privilege escalation
`ansible_become_password`	Equivalent to `ansible_sudo_password` or `ansible_su_password`, allows you to set the privilege escalation password
`ansible_become_exe`	Equivalent to `ansible_sudo_exe` or `ansible_su_exe`, allows you to set the executable for the escalation method selected
`ansible_become_flags`	Equivalent to `ansible_sudo_flags` or `ansible_su_flags`, allows you to set the flags passed to the selected escalation method.
`ansible_shell_type`	The shell type of the target system.
`ansible_python_interpreter`	The target host python path.
`ansible_*_interpreter`	Works for anything such as ruby or perl and works just like `ansible_python_interpreter`. This replaces shebang of modules which will run on that host.

Ansible Playbook

Hello World

- hosts: all
 tasks:
 - name: Print message
 debug:
 msg: Hello world!

Privilege Escalation

# Activate privilege escalation for all tasks.
- hosts: all
 become: yes
 tasks:
 - name: Print message
 debug:
 msg: Hello world!


# Activate privilege escalation for a specific task.
- hosts: all
 tasks:
 - name: Print message
 become: yes
 debug:
 msg: Hello world!


# Run command with another user.
- hosts: all
 tasks:
 - name: Print message
 become: yes
 become_user: <another-user>
 debug:
 msg: Hello world!

Commonly Used Modules

Package

- name: Install a package (state=present is optional)
 apt:
 name: <package-name>
 state: present

- name: Remove a package
 apt:
 name: <package-name>
 state: absent

- name: Install a list of packages
 apt:
 pkg:
 - <package1-name>
 - <package2-name>

- name: Upgrade all packages to the latest version
 apt:
 name: "*"
 state: latest

- name: Update all packages to the latest version
 apt:
 upgrade: dist

- name: Run the equivalent of "apt-get update"
 apt:
 update_cache: yes

- name: Install a .deb package
 apt:
 deb: <deb-filepath>

- name: Install the build dependencies for a package
 apt:
 pkg: <package-name>
 state: build-dep

- name: Install a .deb package from the internet
 apt:
 deb: <deb-url>

- name: Remove useless packages from the cache
 apt:
 autoclean: yes

- name: Remove dependencies that are no longer required
 apt:
 autoremove: yes

Service

- name: Start service <service-name>, if not started
 service:
 name: <service-name>
 state: started

- name: Stop service <service-name>, if started
 service:
 name: <service-name>
 state: stopped

- name: Restart service <service-name>, in all cases
 service:
 name: <service-name>
 state: restarted

- name: Reload service <service-name>, in all cases
 service:
 name: <service-name>
 state: reloaded

- name: Enable service <service-name>, and not touch the state
 service:
 name: <service-name>
 enabled: yes

File Basics

- name: Change file ownership, group and permissions
 file:
 path: <filepath>
 owner: <username>
 group: <group-name>
 mode: <file-mode> # file-mode can be numbers like 0644, or symbols like u=rw,g=r,o=r, or symbol changes u+rw,g-wx,o-rwx.

- name: Create a symbolic link
 file:
 src: <filepath-to-link-to>
 dest: <symlink-path>
 owner: <username>
 group: <group-name>
 state: link

- name: Create two hard links
 file:
 src: <filepath-to-link-to>
 dest: <symlink-path>
 state: hard

- name: Create an empty file.
 file:
 path: <filepath>
 state: touch
 mode: <file-mode>

- name: Create a directory if it does not exist
 file:
 path: <dir-path>
 state: directory
 mode: <file-mode>

- name: Recursively change ownership of a directory
 file:
 path: <dir-path>
 owner: <username>
 group: <group-name>
 state: directory
 recurse: yes

- name: Remove a file
 file:
 path: <filepath>
 state: absent

- name: Recursively remove directory
 file:
 path: <dir-path>
 state: absent

File Copy

- name: Copy file with owner and permissions.
 copy:
 src: <src-filepath>
 dest: <dst-filepath>
 owner: <username>
 group: <group-name>
 mode: <file-mode> # file-mode can be numbers like 0644, or symbols like u=rw,g=r,o=r, or symbol changes u+rw,g-wx,o-rwx.

- name: Copy a file, backing up the original one if it differs from the copied version
 copy:
 src: <src-filepath>
 dest: <dst-filepath>
 owner: <username>
 group: <group-name>
 mode: <file-mode>
 backup: yes

- name: Copy a new "sudoers" file into place, after passing validation with visudo
 copy:
 src: /mine/sudoers
 dest: /etc/sudoers
 validate: /usr/sbin/visudo -csf %s

- name: Copy a "sudoers" file on the remote machine for editing
 copy:
 src: /etc/sudoers
 dest: /etc/sudoers.edit
 remote_src: yes
 validate: /usr/sbin/visudo -csf %s

- name: Copy using inline content
 copy:
 content: 'this is the file content'
 dest: <filepath>

LineInFile

- name: If a line matches <line-pattern>, replace it with <line>
 lineinfile:
 path: <filepath>
 regexp: <line-pattern>
 line: <line>

- name: If a line matches <line-pattern>, remove it
 lineinfile:
 path: <filepath>
 regexp: <line-pattern>
 state: absent

- name: If a line matches <line-pattern>, replace it with <line> and place it after the line <insert-line-pattern>
 lineinfile:
 path: <filepath>
 regexp: <line-pattern>
 insertafter: <insert-line-pattern>
 line: <line>

- name: If a line matches <line-pattern>, replace it with <line> and place it before the line <insert-line-pattern>
 lineinfile:
 path: <filepath>
 regexp: <line-pattern>
 insertbefore: <insert-line-pattern>
 line: <line>

- name: Add <line> to a file. Create the file if it doesn't exist
 lineinfile:
 path: <filepath>
 line: <line>
 create: yes

Commands

- name: Execute a command, and send the output to a variable
 command: <command>
 register: <var-name>

- name: Run command if filepath does not exist
 command: <command>
 args:
 creates: <filepath>

- name: Run command in a specific directory
 command: <command>
 args:
 chdir: <dir>

Git

- git:
 name: Check out a git repo to a specific version (which can be HEAD, a branch, or a tag)
 repo: <git-repo-url>
 dest: <checkout-dir-path>
 version: <version>

- git:
 name: Ensure a git repo checkout exists.
 repo: <git-repo-url>
 dest: <checkout-dir-path>
 update: no

User

- name: Add a specific user with a uid (e.g., 1040)
 user:
 name: <username>
 comment: <comment>
 uid: <uid>
 group: <group>

- name: Add a uesr and append groups to the user's groups
 user:
 name: <username>
 groups: <group_1>,<group_2>,...,<group_n>
 append: yes

- name: Remove a user
 user:
 name: <username>
 state: absent
 remove: yes

- name: Add a user with an expire time
 user:
 name: <username>
 groups: <group_1>,<group_2>,...,<group_n>
 expires: <expire-timestamp>

- name: Remove user's expire time
 user:
 name: <username>
 expires: -1

Debug

- name: Print hostname and uuid
 debug:
 msg: System {{ inventory_hostname }} has uuid {{ ansible_product_uuid }}

- name: print hostname and uuid conditionally
 debug:
 msg: System {{ inventory_hostname }} has gateway {{ ansible_default_ipv4.gateway }}
 when: ansible_default_ipv4.gateway is defined

All Modules

A list of all modules can be found here.

Commands

Run Command For A Single Module

# Ping hosts in group all.
ansible all -m ping

# Ping hosts in group all with a given hosts.ini.
ansible -i hosts.ini all -m ping

# Ping hosts in a group with a given hosts.ini.
ansible -i hosts.ini <group-name> -m ping

# Run a task with a specific module.
ansible -i hosts.ini <group-name> -m <module-name> -a "<module-arg-1-key>=<module-arg-1-value> <module-arg-2-key>=<module-arg-2-value> ... <module-arg-n-key>=<module-arg-n-value>"

# Touch a file.
ansible -i hosts.ini all -m file -a "path=~/file-to-touch mode=0644 state=touch"

Run Command For A Playbook

# Run a playbook for group all.
ansible-playbook -i hosts.ini <playbook-yml-file>

# Run a playbook for a group.
ansible-playbook -i hosts.ini <playbook-yml-file> <group-name>

# Run a playbook for a host.
ansible-playbook -i hosts.ini <playbook-yml-file> <hostname>

# Show hosts information.
ansible-playbook -i hosts.ini <playbook-yml-file> --list-hosts

# Show tasks information.
ansible-playbook -i hosts.ini <playbook-yml-file> --list-tasks

# Perform playbook syntax check.
ansible-playbook --syntax-check <playbook-yml-file>

Cheatsheets: ASCII Code Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

ASCII Code Table

Symbol	Dec	Oct	Hex	Bin
NUL (Null)	0	0	0	00000000
SOH (Start of Heading)	1	1	1	00000001
STX (Start of Text)	2	2	2	00000010
ETX (End of Text)	3	3	3	00000011
EOT (End of Transmission)	4	4	4	00000100
ENQ (Enquiry)	5	5	5	00000101
ACK (Acknowledgment)	6	6	6	00000110
BEL (Bell)	7	7	7	00000111
BS (Back Space)	8	10	8	00001000
HT (Horizontal Tab)	9	11	9	00001001
LF (Line Feed)	10	12	0A	00001010
VT (Vertical Tab)	11	13	0B	00001011
FF (Form Feed)	12	14	0C	00001100
CR (Carriage Return)	13	15	0D	00001101
SO (Shift Out / X-On)	14	16	0E	00001110
SI (Shift In / X-Off)	15	17	0F	00001111
DLE (Data Line Escape)	16	20	10	00010000
DC1 (Device Control 1 / oft. XON)	17	21	11	00010001
DC2 (Device Control 2)	18	22	12	00010010
DC3 (Device Control 3 / oft. XOFF)	19	23	13	00010011
DC4 (Device Control 4)	20	24	14	00010100
NAK (Negative Acknowledgement)	21	25	15	00010101
SYN (Synchronous Idle)	22	26	16	00010110
ETB (End of Transmit Block)	23	27	17	00010111
CAN (Cancel)	24	30	18	00011000
EM (End of Medium)	25	31	19	00011001
SUB (Substitute)	26	32	1A	00011010
ESC (Escape)	27	33	1B	00011011
FS (File Separator)	28	34	1C	00011100
GS (Group Separator)	29	35	1D	00011101
RS (Record Separator)	30	36	1E	00011110
US (Unit Separator)	31	37	1F	00011111
(Space)	32	40	20	00100000
!	33	41	21	00100001
"	34	42	22	00100010
#	35	43	23	00100011
$	36	44	24	00100100
%	37	45	25	00100101
&	38	46	26	00100110
'	39	47	27	00100111
(	40	50	28	00101000
)	41	51	29	00101001
*	42	52	2A	00101010
+	43	53	2B	00101011
,	44	54	2C	00101100
-	45	55	2D	00101101
.	46	56	2E	00101110
/	47	57	2F	00101111
0	48	60	30	00110000
1	49	61	31	00110001
2	50	62	32	00110010
3	51	63	33	00110011
4	52	64	34	00110100
5	53	65	35	00110101
6	54	66	36	00110110
7	55	67	37	00110111
8	56	70	38	00111000
9	57	71	39	00111001
:	58	72	3A	00111010
;	59	73	3B	00111011
<	60	74	3C	00111100
=	61	75	3D	00111101
>	62	76	3E	00111110
?	63	77	3F	00111111
@	64	100	40	01000000
A	65	101	41	01000001
B	66	102	42	01000010
C	67	103	43	01000011
D	68	104	44	01000100
E	69	105	45	01000101
F	70	106	46	01000110
G	71	107	47	01000111
H	72	110	48	01001000
I	73	111	49	01001001
J	74	112	4A	01001010
K	75	113	4B	01001011
L	76	114	4C	01001100
M	77	115	4D	01001101
N	78	116	4E	01001110
O	79	117	4F	01001111
P	80	120	50	01010000
Q	81	121	51	01010001
R	82	122	52	01010010
S	83	123	53	01010011
T	84	124	54	01010100
U	85	125	55	01010101
V	86	126	56	01010110
W	87	127	57	01010111
X	88	130	58	01011000
Y	89	131	59	01011001
Z	90	132	5A	01011010
[	91	133	5B	01011011
\	92	134	5C	01011100
]	93	135	5D	01011101
^	94	136	5E	01011110
_	95	137	5F	01011111
`	96	140	60	01100000
a	97	141	61	01100001
b	98	142	62	01100010
c	99	143	63	01100011
d	100	144	64	01100100
e	101	145	65	01100101
f	102	146	66	01100110
g	103	147	67	01100111
h	104	150	68	01101000
i	105	151	69	01101001
j	106	152	6A	01101010
k	107	153	6B	01101011
l	108	154	6C	01101100
m	109	155	6D	01101101
n	110	156	6E	01101110
o	111	157	6F	01101111
p	112	160	70	01110000
q	113	161	71	01110001
r	114	162	72	01110010
s	115	163	73	01110011
t	116	164	74	01110100
u	117	165	75	01110101
v	118	166	76	01110110
w	119	167	77	01110111
x	120	170	78	01111000
y	121	171	79	01111001
z	122	172	7A	01111010
{	123	173	7B	01111011
\|	124	174	7C	01111100
}	125	175	7D	01111101
~	126	176	7E	01111110
(Delete)	127	177	7F	01111111
€	128	200	80	10000000
	129	201	81	10000001
‚	130	202	82	10000010
ƒ	131	203	83	10000011
„	132	204	84	10000100
…	133	205	85	10000101
†	134	206	86	10000110
‡	135	207	87	10000111
ˆ	136	210	88	10001000
‰	137	211	89	10001001
Š	138	212	8A	10001010
‹	139	213	8B	10001011
Œ	140	214	8C	10001100
	141	215	8D	10001101
Ž	142	216	8E	10001110
	143	217	8F	10001111
	144	220	90	10010000
‘	145	221	91	10010001
’	146	222	92	10010010
“	147	223	93	10010011
”	148	224	94	10010100
•	149	225	95	10010101
–	150	226	96	10010110
—	151	227	97	10010111
˜	152	230	98	10011000
™	153	231	99	10011001
š	154	232	9A	10011010
›	155	233	9B	10011011
œ	156	234	9C	10011100
	157	235	9D	10011101
ž	158	236	9E	10011110
Ÿ	159	237	9F	10011111
(Non-breaking space)	160	240	A0	10100000
¡	161	241	A1	10100001
¢	162	242	A2	10100010
£	163	243	A3	10100011
¤	164	244	A4	10100100
¥	165	245	A5	10100101
¦	166	246	A6	10100110
§	167	247	A7	10100111
¨	168	250	A8	10101000
©	169	251	A9	10101001
ª	170	252	AA	10101010
«	171	253	AB	10101011
¬	172	254	AC	10101100
(Soft hyphen)	173	255	AD	10101101
®	174	256	AE	10101110
¯	175	257	AF	10101111
°	176	260	B0	10110000
±	177	261	B1	10110001
²	178	262	B2	10110010
³	179	263	B3	10110011
´	180	264	B4	10110100
µ	181	265	B5	10110101
¶	182	266	B6	10110110
·	183	267	B7	10110111
¸	184	270	B8	10111000
¹	185	271	B9	10111001
º	186	272	BA	10111010
»	187	273	BB	10111011
¼	188	274	BC	10111100
½	189	275	BD	10111101
¾	190	276	BE	10111110
¿	191	277	BF	10111111
À	192	300	C0	11000000
Á	193	301	C1	11000001
Â	194	302	C2	11000010
Ã	195	303	C3	11000011
Ä	196	304	C4	11000100
Å	197	305	C5	11000101
Æ	198	306	C6	11000110
Ç	199	307	C7	11000111
È	200	310	C8	11001000
É	201	311	C9	11001001
Ê	202	312	CA	11001010
Ë	203	313	CB	11001011
Ì	204	314	CC	11001100
Í	205	315	CD	11001101
Î	206	316	CE	11001110
Ï	207	317	CF	11001111
Ð	208	320	D0	11010000
Ñ	209	321	D1	11010001
Ò	210	322	D2	11010010
Ó	211	323	D3	11010011
Ô	212	324	D4	11010100
Õ	213	325	D5	11010101
Ö	214	326	D6	11010110
×	215	327	D7	11010111
Ø	216	330	D8	11011000
Ù	217	331	D9	11011001
Ú	218	332	DA	11011010
Û	219	333	DB	11011011
Ü	220	334	DC	11011100
Ý	221	335	DD	11011101
Þ	222	336	DE	11011110
ß	223	337	DF	11011111
à	224	340	E0	11100000
á	225	341	E1	11100001
â	226	342	E2	11100010
ã	227	343	E3	11100011
ä	228	344	E4	11100100
å	229	345	E5	11100101
æ	230	346	E6	11100110
ç	231	347	E7	11100111
è	232	350	E8	11101000
é	233	351	E9	11101001
ê	234	352	EA	11101010
ë	235	353	EB	11101011
ì	236	354	EC	11101100
í	237	355	ED	11101101
î	238	356	EE	11101110
ï	239	357	EF	11101111
ð	240	360	F0	11110000
ñ	241	361	F1	11110001
ò	242	362	F2	11110010
ó	243	363	F3	11110011
ô	244	364	F4	11110100
õ	245	365	F5	11110101
ö	246	366	F6	11110110
÷	247	367	F7	11110111
ø	248	370	F8	11111000
ù	249	371	F9	11111001
ú	250	372	FA	11111010
û	251	373	FB	11111011
ü	252	374	FC	11111100
ý	253	375	FD	11111101
þ	254	376	FE	11111110
ÿ	255	377	FF	11111111

Cheatsheets: Docker Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Installation

Install Docker On Ubuntu

# Update the apt package index and install packages to allow apt to use a repository over HTTPS.
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release

# Add Docker’s official GPG key.
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# set up the repository.
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install docker.
sudo apt update && sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y

# Verify if docker is successfully installed.
sudo docker run hello-world

Install Docker On Debian

# Update the apt package index and install packages to allow apt to use a repository over HTTPS.
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release

# Add Docker’s official GPG key.
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Set up the repository.
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install docker.
sudo apt update && sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Verify if docker is successfully installed.
sudo docker run hello-world

Run Docker Commands Without Sudo

# Create a docker group and add yourself to it,
# so that you don't need sudo before your docker command.
# Note that you'll need to log out and log in for the changes to take effect.
sudo groupadd docker
sudo usermod -aG docker $USER

Commands

Image Management

# Build an image.
docker build -t <image-name>

# Build an Image without using cache.
docker build -t <image-name> . –no-cache

# List local images.
docker images

# Create a docker image from a running container.
docker commit <container-name-or-id> <image-name>

# Delete a local image.
docker rmi <image-name>

# Remove all unused images.
docker image prune

# Remove all unused containers, images, caches.
docker system prune

# Push docker image to docker registry.
# Image name has to be in the form of <docker-registry-address>/<docker-repo>[:<docker-tag>].
# Examples are:
# * docker-repo.local/my-image
# * docker-repo.local/my-image:debug
docker push <image-name>

# Remove dangling images.
docker images -qf dangling=true | xargs docker rmi

Container Management

# Create a docker container.
docker create <image-name>

# Run a container from an image.
docker run <image-name>

# Run a container in interactive mode.
docker run -it <image-name>

# Run a container in the background.
docker run -d <image-name>

# Run a container with a port mapping.
docker run -p <host-port>:<container-port> <image-name>

# Start an existing container.
docker start <container-id-or-name>

# Restart a container.
docker restart <container-id-or-name>

# Pause a container.
docker pause <container-id-or-name>

# Unpause a container.
docker unpause <container-id-or-name>

# Wait until running container stops.
docker wait <container-id-or-name>

# Stop a container.
docker stop <container-id-or-name>

# Kill a container.
docker kill <container-id-or-name>

# Attach a container. (C-p C-q to detach)
docker attach <container-id-or-name>

# Rename a container.
docker rename <container-id-or-name> <new-name>

# Update a container.
docker update [OPTIONS] <container-id-or-name>

# Remove a stopped container.
docker rm <container-id-or-name>

# Follow the logs of a container.
docker logs -f <container-id-or-name>

# Inspect a running container.
docker inspect <container-id-or-name>

# List running containers.
docker ps

# List all containers.
docker ps -a

File Copy

# Copy files from host to container.
docker cp <host-filepath> <container-id-or-name>:<container-filepath>

# Copy files from container to host.
docker cp <container-id-or-name>:<container-filepath> <host-filepath>

# Export all files in container to host.
docker export <container-id-or-name> -o <filename>

Network Management

# Create a docker network.
docker network create --subnet <subnet> --gateway <gateway> <docker-network-name>

# Remove a docker network.
docker network rm <docker-network-name>

# List all docker networks.
docker network ls

# Inspect a docker network.
docker network inspect <docker-network-name>

# Connect a container with a docker network.
docker network connect <docker-network-name> <container-id-or-name>

# Disconnect a container with a docker network.
docker network disconnect <docker-network-name> <container-id-or-name>

Docker In Docker

# Run a docker container which maps the /var/run/docker.sock file,
# so that you can run another docker container within this one.
docker run -v /var/run/docker.sock:/var/run/docker.sock -it <image-name>

Dockerfile Builder Commands

Command	Description
`FROM <image-name>`	Docker base image name.
`MAINTAINER <email>`	Maintainer’s email address.
`COPY <src-file-on-host> <dst-file-on-docker>`	Copy files from host to docker image.
`RUN <command>`	Run a command when building the image.
`USER <username>`	Set the default user name.
`WORKDIR <dir>`	Set the default working directory.
`CMD <command>`	Start up default command which can be overridden by docker cli.
`ENTRYPOINT <command>`	Start up default command which cannot be overridden by docker cli.
`ENV <env-name> <env-value>`	Environment variables.

Docker Config

Insecure Docker Registry

# Add the following content to /etc/docker/daemon.json if you using an insecure docker registry.
{
 "insecure-registries" : ["<your-docker-register-server-ip-or-hostname>"]
}

Cheatsheets: Docker Compose Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

Basics

# Build or rebuild services
docker compose build

# Creates containers for a service.
docker compose create

# Start services
docker compose start

# Restart service containers
docker compose restart

# Create and start containers
docker compose up

# Run a one-off command on a service.
docker compose run

# Pause services
docker compose pause

# Unpause services
docker compose unpause

# Stop services
docker compose stop

# Removes stopped service containers
docker compose rm

# Stop and remove containers, networks
docker compose down

# Force stop service containers.
docker compose kill

# Execute a command in a running container.
docker compose exec

Check Status

# List running compose projects
docker compose ls

# List containers
docker compose ps

# Print the public port for a port binding.
docker compose port

# Receive real time events from containers.
docker compose events

# View output from containers
docker compose logs

# Display the running processes
docker compose top

Images

# Pull service images
docker compose pull

# Push service images
docker compose push

# List images used by the created containers
docker compose images

File Operations

# Copy files/folders from a service container to the local filesystem
docker compose cp <service>:<src-filepath> <dst-filepath>

# Copy files/folders from the local filesystem to a service container.
docker compose cp <src-filepath> <service>:<dst-filepath>

Others

# Show the Docker Compose version information
docker compose version

# Converts the compose file to platform’s canonical format
docker compose convert

Docker Compose Config

An Basic Example

version: '3.9'

services:
 hello-world:
 image: hello-world:latest

Spec

Build

services:
 web:
 # Build from Dockerfile
 build: .

 # Build arguments.
 args:
 APP_HOME: app

 # Build from custom Dockerfile
 build:
 context: ./dir
 dockerfile: Dockerfile.dev

 # Build image.
 image: debian
 image: ubuntu
 image: ubuntu:20.04

Network

services:
 web:
 # Set container network mode.
 network_mode: "host"
 network_mode: "none"
 network_mode: "service:[service name]"

 # Define the networks that service containers are attached to.
 networks:
 - some-network
 - other-network

 # Expose container ports.
 ports:
 - "3000"
 - "3000-3005"
 - "8000:8000"
 - "9090-9091:8080-8081"
 - "49100:22"
 - "127.0.0.1:8001:8001"
 - "127.0.0.1:5000-5010:5000-5010"
 - "6060:6060/udp"

 # Define dns server.
 dns: 8.8.8.8

 # Define custom DNS search domains to set on container network interface configuration.
 dns_search: example.com

 # List custom DNS options to be passed to the container’s DNS resolver.
 dns_opt:
 - use-vc
 - no-tld-query

 # Defines a network link to containers in another service.
 links:
 - db
 - db:database
 - redis

Environment Variable

services:
 web:
 # Define environment variables.
 environment:
 RACK_ENV: development
 SHOW: "true"
 USER_INPUT:
 COMPOSE_PROJECT_NAME: "foo"

 # Define environment variables from file.
 env_file: .env
 env_file:
 - ./a.env
 - ./b.env

Commands

services:
 web:
 # Start up command, which overrides the image default command.
 command: echo "I'm running ${COMPOSE_PROJECT_NAME}"

 # Start up command in the list form, which overrides the image default command.
 entrypoint:
 - php
 - -d
 - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
 - -d
 - memory_limit=-1
 - vendor/bin/phpunit

Labels

services:
 web:
 # Container label meta data.
 labels:
 com.example.description: "Accounting webapp"
 com.example.department: "Finance"
 com.example.label-with-empty-value: ""

Logging

services:
 web:
 # Define logging.
 logging:
 driver: syslog
 options:
 syslog-address: "tcp://192.168.0.42:123"

Dependencies

services:
 web:
 build: .
 # Define startup and shutdown dependencies between services.
 depends_on:
 - db
 - redis
 redis:
 image: redis
 db:
 image: postgres

Cheatsheets: Git Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

New Repo

# Create a new local git repo.
git init [project name]

# Clone a git repo.
git clone <url>

# Clone a git repo to a local dir.
git clone <url> <local-dir>

Config

# Set your user name.
git config --global user.name "name"

# Set your email address.
git config --global user.email "email"

# Edit git global config.
git config --global --edit

Branch

# List all local branches.
git branch

# List all local and remote branches.
git branch -a

# Check out to another branch.
git checkout <branch-name>

# Check out to the previous branch.
git checkout -

# Create a new local branch and check it out.
git checkout -b <branch-name>

# Delete a local local branch.
git branch -D <branch-name>

# Merge the target branch changes into the current branch.
git merge <branch-name>

# Merge a commit into the current branch.
git cherry-pick <commit-id>

# Rebase the current branch onto the target branch.
git rebase <branch-name>

# Fetch all remote branches from alias.
git fetch [alias]

# Fetch and merge commits from tracking remote branch
git pull

# Push a local branch to remote with same branch name.
git push [alias] [branch]

# Push a local branch to another remote branch.
git push [alias] [local-branch]:[remote-branch]

# Delete a remote branch
git push origin --delete <branch-name>

# Fetch master branch from other branch and rebase on it.
git fetch origin master:master && git rebase master

Changes

# Show local changes.
git status

# Stage file.
git add <file>

# Unstage file.
git reset <file>

# Stage changes for all tracked files.
git add .

# Commit all staged changes.
git commit -m "commit message"

# Amend last commit
git commit --amend -m "new message"

# Reset everything to last commit.
git reset --hard

# Delete all untracked files and directories.
git clean -df

# Undo local modifications to all files.
git checkout -- .

# Show non-staged changes.
git diff

# Show staged changes.
git diff --staged

# Save the current changes
git stash

# List all the stashed changes.
git stash list

# Pop the last stashed change.
git stash pop

# Drop the last stashed change.
git stash drop

# Show commit logs.
git log

# Show pretty commit logs.
git log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --first-parent

Remote

# Create a new alias for a git URL.
git remote add <alias> <url>

# Show the remote repo names you have.
git remote

# Show the remote repo names and urls you have.
git remote -v

# Remote a remove repo.
git remote rm <remote-repo-name>

# Change the URL of the origin alias.
git remote set-url origin [git-url]

Submodule

# Create a submodule.
git submodule add <git-repo-url> <submodule-dir-path>

# Init submodules.
git submodule init

# Update and init submodules recursively.
git submodule update -i -r

# Set a new url for the submodule.
git submodule set-url -- <submodule-dir-path> <new-git-repo-url>

# Sync all submodules.
git submodule sync

# Execute command for each submodule.
git submodule foreach --recursive <command>

Aliases

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

Cheatsheets: Kubernetes Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Kubectl Commands

Annotate

# Annotate a resource with the key and value.
kubectl annotate <resource-type> <resource-name> <key>=<value>

# Override annotation of a resource.
kubectl annotate --overwrite <resource-type> <resource-name> <key>=<value>

# Annotate annotation of all resources.
kubectl annotate --all <resource-type> <resource-name> <key>=<value>

# Remove an annotation from a resource.
kubectl annotate <resource-type> <resource-name> <key>-

Api Version

# Show API versions.
kubectl api-versions

Apply

# Apply the config in <config-file>.
kubectl apply -f <config-file>

# Another way to apply the config in <config-file>.
cat <config-file> | kubectl apply -f -

# Apply the config string.
echo '<config-string>' | kubectl apply -f -

Attach

# Attach to the first container in a pod.
kubectl attach <pod-name>

# Attach to a container in a pod.
kubectl attach <pod-name> -c <container-name>

Autoscale

# Auto scale a deployment.
kubectl autoscale deployment <deployment-name> --min=<min-pods-number> --max=<max-pods-number> --cpu-percent=<cpu-percentage>

# Auto scale a replication controller.
kubectl autoscale rc <rc-name> --min=<min-pods-number> --max=<max-pods-number> --cpu-percent=<cpu-percentage>

Cluster Info

# Display addresses of the master and services.
kubectl cluster-info

# Dump current cluster state to stdout.
kubectl cluster-info dump

# Dump current cluster state to <output-directory>.
kubectl cluster-info dump --output-directory=<output-directory>

Config

View Config

# View kubectl config.
kubectl config view

Context

# Display the current-context.
kubectl config current-context

# Get available contexts.
kubectl config get-contexts

# Sets the current-context in a kubeconfig file.
kubectl config use-context <context-name>

# Set cluster field for context.
kubectl config set-context <context-name> --cluster=<cluster-name>

# Set user field for context.
kubectl config set-context <context-name> --user=<username>

# Set namespace field for context.
kubectl config set-context <context-name> --namespace=<namespace>

Cluster

# Set only the server field on the cluster entry without touching other values.
kubectl config set-cluster <cluster-name> --server=<server-endpoint>

# Embed certificate authority data for the cluster entry.
kubectl config set-cluster <cluster-name> --certificate-authority=<crt-file-path>

# Enable/disable cert checking for the cluster entry.
kubectl config set-cluster <cluster-name> --insecure-skip-tls-verify=<boolean>

Credentials

# Set only the "client-key" field without touching other values.
kubectl config set-credentials <username> --client-key=<client-key-filepath>

# Set the authentication username and password for user.
kubectl config set-credentials <username> --username=<auth-username> --password=<auth-password>

# Embed client certificate data for user.
kubectl config set-credentials <username> --client-certificate=<crt-filepath> --embed-certs=true

Others

# Sets an individual value in a kubeconfig file.
kubectl config set <property-name> <property-value>

# Unsets an individual value in a kubeconfig file.
kubectl config unset <property-name>

Cordon & Uncordon

# Mark node as unschedulable.
kubectl cordon <node-name>

# Mark node as schedulable.
kubectl uncordon <node-name>

Create

# Create a resource by filename or stdin
kubectl create -f <filename>

# Another way to create the config in <config-file>.
cat pod.yaml | kubectl create -f -

# Create a resource with the config string.
echo '<config-string>' | kubectl create -f -

Delete

# Delete a resource.
kubectl delete <resource-type> <resource-name>

# Delete a resource matching a label.
kubectl delete <resource-type> -l <label-key>=<label-value>

# Delete all resources of certain type.
kubectl delete <resource-type> --all

Describe

# Describe a resource.
kubectl describe <resource-type>/<resource-name>

# Describe a resource matching a label.
kubectl describe <resource-type> -l <label-key>=<label-value>

Drain

# Drain a node for maintenance.
kubectl drain <node-name>

# Drain a node for maintenance forcefully.
kubectl drain <node-name> --force

# Drain a node with a grace period.
kubectl drain <node-name> --grace-period=<grace-period-in-seconds>

Edit

# Edit a resource.
kubectl edit <resource-type>/<resource-name>

Exec

# Execute a command in a container.
kubectl exec <pod-name> [-c <container-name>] -- <command>

Explain

# Explain a resource.
kubectl explain <resource-type>

Expose

# Create a service for a replica, which maps the container <target-port> to <port>.
kubectl expose rc <rc-name> --port=<port> --target-port=<target-port> [--name=<name>]

# Create a second service based on an existing service, which maps the container <target-port> to <port>.
kubectl expose service <service-name> --port=<port> --target-port=<target-port> [--name=<name>]

Get

# List all resources of type <resource-type>.
kubectl get <resource-type>

# List all resources of type <resource-type> in json.
kubectl get <resource-type> -o json

# List all resources of type <resource-type> with more details.
kubectl get <resource-type> -o wide

# List the resource with name of <resource-name>.
kubectl get <resource-type> <resource-name>

Label

# Label a resource with the key and value.
kubectl label <resource-type> <resource-name> <key>=<value>

# Override annotation of a resource.
kubectl label --overwrite <resource-type> <resource-name> <key>=<value>

# Label annotation of all resource.
kubectl label --all <resource-type> <resource-name> <key>=<value>

# Remove an annotation of a resource.
kubectl label <resource-type> <resource-name> <key>-

Logs

# Show logs for the first container of a pod.
kubectl logs <pod-name>

# Show logs for a container in the pod.
kubectl logs <pod-name> -c <container-name>

# Show of a previous terminated pod.
kubectl logs <pod-name> -p

# Follow the log of a pod.
kubectl logs <pod-name> -f

# Show last few lines of logs in a pod.
kubectl logs <pod-name> --tail=<number-of-lines>

# Show all logs for a pod since <time-duration> (e.g., 5m, 1h).
kubectl logs --since=<time-duration> <pod-name>

Patch

# Patch a node. An example of json-string is {"spec":{"unschedulable":true}}.
kubectl patch node <node-name> -p '<json-string>'

Port Forward

# Forward container's <port> to host's <port>.
kubectl port-forward <pod-name> <port>

# Forward container's <container-port> to host's <host-port>.
kubectl port-forward <pod-name> <host-port>:<container-port>

# Forward container's <container-port> to host's random port.
kubectl port-forward <pod-name> :<container-port>

# Forward container's <container-port> to host's random port.
kubectl port-forward <pod-name> 0:<container-port>

Proxy

# Run a proxy on port <proxy-port>.
kubectl proxy --port=<proxy-port>

# Run a proxy on an arbitrary port.
kubectl proxy --port=0

Replace

# Replace the config in <config-file>.
kubectl replace -f <config-file>

# Another way to replace the config in <config-file>.
cat <config-file> | kubectl replace -f -

# Another way to replace the config string.
echo '<config-string>' | kubectl replace -f -

Rolling Update

# Rolling update pods in <rc-name> with <config-file>.
kubectl rolling-update <rc-name> -f <config-file>

# Another way to rolling update pods in <rc-name> with <config-file>.
cat <config-file> | kubectl rolling-update <rc-name> -f -

# Another way to rolling update pods in <rc-name> with the config string.
echo '<config-string>' | kubectl rolling-update -f -

# Update the pods in <rc-name> with a new image.
kubectl rolling-update <rc-name> --image=<image-name>

# Abort and reverse an existing rollout in progress.
kubectl rolling-update <rc-name> --rollback

Rollout

# View the rollout history of a resource.
kubectl rollout history <resource-type>/<resource-name>

# Pause a resource rollout.
kubectl rollout pause <resource-type>/<resource-name>

# Unpause a resource rollout.
kubectl rollout unpause <resource-type>/<resource-name>

# Rollback a resource rollout.
kubectl rollout rollback <resource-type>/<resource-name>

Run

# Start a pod with <image-name>.
kubectl run <pod-name> --image=<image-name>

# Start a pod with <image-name> with an environment variable KEY=VALUE.
kubectl run <pod-name> --image=<image-name> --env="KEY=VALUE"

# Start a pod with <image-name>, and let the container expost <port>.
kubectl run <pod-name> --image=<image-name> --port=<port>

# Dry run. Print the corresponding API objects without creating them.
kubectl run <pod-name> --image=<image-name> --dry-run=client

# Run a container interactively.
kubectl run -it <pod-name> --image=<image-name>

# Run a container with <command>.
kubectl run <pod-name> --image=<image-name> -- <command>

Scale

# Scale a replication controller to <number-of-relicas>.
kubectl scale --replicas=<number-of-relicas> rc/<fc-name>

# Scale a job to <number-of-relicas>.
kubectl scale --replicas=<number-of-relicas> job/<job-name>

Version

# Print the client and server version information.
kubectl version

Resource

Common Resource Kinds

Name	Shortnames	Namespaced	Kind
bindings		true	Binding
componentstatuses	cs	false	ComponentStatus
configmaps	cm	true	ConfigMap
endpoints	ep	true	Endpoints
events	ev	true	Event
limitranges	limits	true	LimitRange
namespaces	ns	false	Namespace
nodes	no	false	Node
persistentvolumeclaims	pvc	true	PersistentVolumeClaim
persistentvolumes	pv	false	PersistentVolume
pods	po	true	Pod
podtemplates		true	PodTemplate
replicationcontrollers	rc	true	ReplicationController
resourcequotas	quota	true	ResourceQuota
secrets		true	Secret
serviceaccounts	sa	true	ServiceAccount
services	svc	true	Service
mutatingwebhookconfigurations		false	MutatingWebhookConfiguration
validatingwebhookconfiguration	s	false	ValidatingWebhookConfiguration
customresourcedefinitions	crd,crds	false	CustomResourceDefinition
apiservices		false	APIService
controllerrevisions		true	ControllerRevision
daemonsets	ds	true	DaemonSet
deployments	deploy	true	Deployment
replicasets	rs	true	ReplicaSet
statefulsets	sts	true	StatefulSet
tokenreviews		false	TokenReview
localsubjectaccessreviews		true	LocalSubjectAccessReview
selfsubjectaccessreviews		false	SelfSubjectAccessReview
selfsubjectrulesreviews		false	SelfSubjectRulesReview
subjectaccessreviews		false	SubjectAccessReview
horizontalpodautoscalers	hpa	true	HorizontalPodAutoscaler
cronjobs	cj	true	CronJob
jobs		true	Job
certificatesigningrequests	csr	false	CertificateSigningRequest
leases		true	Lease
endpointslices		true	EndpointSlice
events	ev	true	Event
flowschemas		false	FlowSchema
prioritylevelconfigurations		false	PriorityLevelConfiguration
ingressclasses		false	IngressClass
ingresses	ing	true	Ingress
networkpolicies	netpol	true	NetworkPolicy
runtimeclasses		false	RuntimeClass
poddisruptionbudgets	pdb	true	PodDisruptionBudget
clusterrolebindings		false	ClusterRoleBinding
clusterroles		false	ClusterRole
rolebindings		true	RoleBinding
roles		true	Role
priorityclasses	pc	false	PriorityClass
csidrivers		false	CSIDriver
csinodes		false	CSINode
csistoragecapacities		true	CSIStorageCapacity
storageclasses	sc	false	StorageClass
volumeattachments		false	VolumeAttachment

Either the resource kind or the short name can be used as <resource-type> in the following commands in this page.
For any namespaced resource, the command has to be appended with -n <namespace>.

Resource Config

Pod

apiVersion: v1
kind: Pod
metadata:
 name: <pod-name>  # e.g., nginx
 namespace: <namespace>  # e.g., nginx
spec:
 containers:
 - name: <container-name>  # e.g., nginx
 image: <image-name>  # e.g., nginx:1.14.2
 ports:
 - containerPort: <container-port> # e.g., 80

Use kubectl get pod <pod-name> -n <namespace> -o yaml to see more configurable fields.

Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
 name: <deployment-name>  # e.g., nginx-deployment
 namespace: <namespace>  # e.g., nginx
 labels:
 app: <deployment-app-label>  # e.g., nginx
spec:
 replicas: <number-of-replicas>  # e.g., 2
 selector:
 matchLabels:
 app: <app-selector>  # e.g., nginx
 template:
 metadata:
 labels:
 app: <pod-app-label>  # e.g., nginx
 spec:
 containers:
 - name: <container-name>  # e.g., nginx
 image: <image-name>  # nginx:1.14.2
 ports:
 - containerPort: <container-port> # e.g., 80

Use kubectl get deployment <deployment-name> -n <namespace> -o yaml to see more configurable fields.

Daemonset

apiVersion: apps/v1
kind: DaemonSet
metadata:
 name: <ds-name>
 namespace: <namespace>
spec:
 selector:
 matchLabels:
 <label-key>: <label-value>
 template:
 metadata:
 labels:
 <label-key>: <label-value>
 spec:
 containers:
 - name: <container-name>
 image: <image-name>

Use kubectl get ds <ds-name> -n <namespace> -o yaml to see more configurable fields.

Job

apiVersion: batch/v1
kind: Job
metadata:
 name: <job-name>  # e.g., pi
 namespace: <namespace>  # e.g., pi
spec:
 template:
 spec:
 containers:
 - name: <container-name> # e.g., pi
 image: <image-name>  # e.g., perl:5.34.0
 command: <cmd-args>  # e.g., ["perl", "-Mbignum=bpi", "-wle", "print bpi(2000)"]
 restartPolicy: Never

Use kubectl get job <job-name> -n <namespace> -o yaml to see more configurable fields.

Cronjob

apiVersion: batch/v1
kind: CronJob
metadata:
 name: <cronjob-name>
 namespace: <namespace>
spec:
 schedule: <schedule>  # e.g., every five minutes "*/5 * * * *"
 jobTemplate:
 spec:
 template:
 spec:
 containers:
 - name: <container-name>
 image: <image-name>
 imagePullPolicy: IfNotPresent
 command: <cmd-args> # e.g., ["/bin/sh", "-c", "date; echo Hello from the Kubernetes cluster"]
 restartPolicy: OnFailure

Use kubectl get cronjob <cronjob-name> -n <namespace> -o yaml to see more configurable fields.

Service

# ClusterIP Service.
apiVersion: v1
kind: Service
metadata:
 name: <service-name>
 namespace: <namespace>
spec:
 type: ClusterIP  # the ClusterIP service type. ClusterIP service is only accessible from within the cluster.
 selector:
 <selector-label-key>: <selector-label-value> # selector for the target pods.
 ports:
 - protocol: <protocol>  # the protocol the service uses, e.g., TCP
 port: <port>  # the port exposed to the cluster, e.g., 80
 targetPort: <target-port>  # the port requests are sent to in the pod, e.g., 9736


# NodePort Service.
apiVersion: v1
kind: Service
metadata:
 name: <service-name>
 namespace: <namespace>
spec:
 type: NodePort  # the NodePort service type. The service can be accessed from outside via your host node.
 selector:
 <selector-label-key>: <selector-label-value> # selector for the target pods.
 ports:
 - port: <port>  # the port exposed to the cluster, e.g., 80
 targetPort: <target-port>  # the port requests are sent to in the pod, e.g., 9736
 nodePort: <node-port>  # the port the host node is exposed to the outside network, e.g. 30010


# LoadBalancer Service
apiVersion: v1
kind: Service
metadata:
 name: <service-name>
 namespace: <namespace>
spec:
 type: LoadBalancer
 selector:
 <selector-label-key>: <selector-label-value> # selector for the target pods.
 ports:
 - protocol: <protocol>  # the protocol the service uses, e.g., TCP
 port: <port>  # the port exposed to the cluster, e.g., 80
 targetPort: <target-port>  # the port requests are sent to in the pod, e.g., 9736

Use kubectl get service <service-name> -n <namespace> -o yaml to see more configurable fields.

Service Account

kind: ServiceAccount
apiVersion: v1
metadata:
 name: <sa-name>  # the service account name
 namespace: <namespace> # the namespace

Use kubectl get sa <sa-name> -n <namespace> -o yaml to see more configurable fields.

Role & ClusterRole

# Role
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
 name: <role-name>  # the role name
 namespace: <namespace> # the namespace
rules:
- apiGroups: <api-group> # e.g., [""]
 resources: <resources> # e.g., ["pods"]
 verbs: <verbs>  # e.g., ["get", "watch", "list"]


# ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
 name: <clusterrole-name> # the role name
rules:
- apiGroups: <api-group>  # e.g., [""]
 resources: <resources>  # e.g., ["pods"]
 verbs: <verbs>  # e.g., ["get", "watch", "list"]

Use kubectl get role <role-name> -n <namespace> -o yaml or kubectl get clusterrole <clusterrole-name> -o yaml to see more configurable fields.

RoleBinding & ClusterRoleBinding

# RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
 name: <rolebinding-name> # the role binding name
 namespace: <namespace>  # the namespace of the role binding
subjects:
- kind: ServiceAccount
 name: <sa-name>  # the sa name
 namespace: <namespace>  # the namespace of the sa
roleRef:
 kind: Role
 name: <role-name>  # the Role name
 apiGroup: rbac.authorization.k8s.io


# ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
 name: <clusterrolebinding-name> # the role binding name
subjects:
- kind: ServiceAccount
 name: <sa-name>  # the sa name
 namespace: <namespace>  # the namespace of the sa
roleRef:
 kind: ClusterRole
 name: <clusterrole-name>  # the cluster role name
 apiGroup: rbac.authorization.k8s.io

Use kubectl get rolebinding <rolebinding-name> -n <namespace> -o yaml or kubectl get clusterrolebinding <clusterrolebinding-name> -o yaml to see more configurable fields.

ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
 name: <cm-name>
 namespace: <namespace>
data:
 <key1>: <value1>
 <key2>: <value2>

Use kubectl get cm <cm-name> -n <namespace> -o yaml to see more configurable fields.

Secret

# Create a secret from command line.
kubectl create secret generic <secret-name> --from-literal=<key1>=<value1> --from-literal=<key2>=<value2>

# Get the secret in json.
kubectl get secret <secret-name> -o jsonpath='{.data}'

# Decode <key> in the secret.
kubectl get secret <secret-name> -o jsonpath='{.data.<key>}' | base64 --decode

Use kubectl get secret <secret-name> -n <namespace> -o yaml to see more configurable fields.

PersistentVolumeClaim

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: <pvc-name>
 namespace: <namespace>
spec:
 accessModes:
 - <access-mode>  # e.g., ReadWriteOnce, ReadOnlyMany, ReadWriteMany, ReadWriteOncePod
 volumeMode: Filesystem
 resources:
 requests:
 storage: <storage-size> # e.g., 10Gi
 storageClassName: <sc-name> # e.g., standard

Use kubectl get pvc <pvc-name> -n <namespace> -o yaml to see more configurable fields.

Cheatsheets: Linux Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

File & Directory Basics

# List files in the current directory.
ls

# List files in the current directory with details.
ls -alh

# Change current directory.
cd

# Show current directory.
pwd

# Create an empty directory.
mkdir

# Copy file.
cp <src-filename> <dst-filename>

# Copy directory.
cp -Rf <src-dirname> <dst-dirname>

# Move file or directory.
mv <src-filename> <dst-filename>

# Remove file.
rm <filename>

# Remove an empty directory.
rmdir <dirname>

# Remove a non-empty directory.
rm -Rf <dirname>

# Create a new empty file.
touch <filename>

# Find files.
find . -iname <filename-regex>

# Find all files.
find . -type f

File Content

# Print file content.
cat <filename>

# Search texts in file.
grep <text> <filename>

# Search regex pattern in file.
grep -e <regex-pattern> <filename>

# Show first few lines in file.
head -n <line-count> <filename>

# Show last few lines in file.
tail -n <line-count> <filename>

# Follow file changes.
tail -f <filename>

File Access

# Change file access. An example of access-code is 600.
chmod <access-code> <filename>

# Change file owner.
chown <owner>[:<group>] <filename>

Package & Compress

# Pack a directory into a tar file.
tar -cvf <tar-filename>.tar <dirname>

# Unpack a tar file.
tar -xvf <tar-filename>.tar

# Zip a file.
zip <zip-filename> file1 file2 file3 ...

# Unzip a file.
unzip <zip-filename>

Disk

# Show free disk spaces for each block device.
df -alh

# Display the disk usage of files under the current directory.
du -h ./*

# Show block devices.
lsblk

Process

# List process.
ps aux

# Kill a process with SIGTERM.
kill <pid>

# Kill a process with SIGKILL (the strongest killing signal).
kill -9 <pid>

# List all processes in a terminal UI.
top

# List all processes in an advanced terminal UI.
htop

Networking

# Download data from url.
curl <url>

# Download data from url to local file.
curl <url> -o <filename>

# List all ports opened.
netstat -an

# List network configuration.
ifconfig

# Ping network connectivity.
ping

User

# Add a new user.
sudo adduser <username>

# Delete a user.
sudo deluser <username>

Packages

# Install packages on ubuntu or debian.
sudo apt install <package-name>[=<version>]

# Uninstall packages from ubuntu or debian.
sudo apt-get --purge remove <package-name>

System

# Display information about your system.
uname -a

# Display Linux release information
lsb_release -a

# Show hostname.
hostname

# Reboot system now.
sudo reboot now

# Shutdown system now.
sudo shutdown -h now

Services

# List all units.
systemctl list-units

# List all service units.
systemctl list-units --type=service

# Start a service.
sudo systemctl start <service-name>

# Restart a service.
sudo systemctl restart <service-name>

# Stop a service.
sudo systemctl stop <service-name>

# Check a service status.
sudo systemctl status <service-name>

# Enable a service to start as system starts.
sudo systemctl enable <service-name>

Configuration Files

File Path	Scope	File Use
`/boot/grub/grub.cfg`	global	the generated grub file
`/etc/bash.bashrc`	global	global config file for bash
`/etc/default/grub`	global	config used by update-grub to generate /boot/grub/grub.cfg
`/etc/dhcp/dhclient.conf`	global	DCHP client configs
`/etc/fstab`	global	startup mount configs
`/etc/hostname`	global	hostname
`/etc/hosts`	global	static dhcp entries
`/etc/mime.types`	global	MIME types and filename extensions associated with them
`/etc/motd`	global	log in prompt message
`/etc/profile`	global	commands for the login shell to execute
`/etc/resolv.conf`	global	DNS server config
`/etc/sudoers`	global	configs for sudoers
`/etc/timezone`	global	local timezone
`~/.bashrc`	user	bash startup config for non-login shell
`~/.editor`	user	sets the default editor for the user
`~/.gitconfig`	user	sets the default configs for git
`~/.profile`	user	shell startup commands
`~/.ssh/config`	user	user ssh config
`~/.vimrc`	user	vim config
`~/.emacs`	user	emacs config
`~/.xinitrc`	user	xmanager config

Cheatsheets: Markdown Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Headers

# h1
## h2
### h3
#### h4
##### h5
###### h6

Header 1
========

Header 2
--------

Quote

> Quote

> > Nested Quote

Lists

* unordered item 1
* unordered item 2
 * unordered item 2.1
 * unordered item 2.2


1. ordered item 1
2. ordered item 2
 1. ordered item 2.1
 2. ordered item 2.2


* [ ] Unordered item with checkbox off
* [x] Unordered item with checkbox on

Tables

| column 1 | column 2 |
|----------|----------|
| Cell 1 | Cell 2 |
| Cell 3 | Cell 4 |


| Text left-aligned column | Text center-aligned column | Text right-aligned column |
|:-------------------------|:--------------------------:|--------------------------:|
| Cell 1 | Cell 2 | Cell 3 |
| Cell 4 | Cell 5 | Cell 6 |

Text Highlights

*italic*

**bold**

~~struck out~~

Code

`inline code`

```
code block
```

```python
print("this is a python code block")
```

```cpp
printf("this is a c++ code block");
```

Links

[devmemo](https://devmemo.gitlab.io)

Images

![Image Title](/path/to/your/image)

![Image Title](https://your-image-url)

Horizontal Line

---

***

___

Backslack Escapes

Character	Description
\	backslash
`	backtick
*	asterisk
_	underscore
{}	curly braces
[]	square brackets
()	parentheses
#	hash mark
+	plus sign
-	minus sign (hyphen)
.	dot
!	exclamation mark

Cheatsheets: Minikube Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Installation

Prerequisite

Install docker before minikube.

Install On Linux

# Install using binary.
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Install minikube using debian package.
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb
sudo dpkg -i minikube_latest_amd64.deb

# Install minikube using rpm package.
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-latest.x86_64.rpm
sudo rpm -Uvh minikube-latest.x86_64.rpm

Install On Mac

# Install using binary on amd64.
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube

# Install using binary on arm.
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-arm64
sudo install minikube-darwin-arm64 /usr/local/bin/minikube

# Install with homebrew on either arm or amd64.
brew install minikube

Kubectl

Run Kubectl Command

# Run kubectl command.
minikube kubectl -- <kubectl commands>

Set Up Kubectl Alias

# Set up kubectl alias for easy use.
alias kubectl="minikube kubectl --"

Cluster

# Start minikube cluster.
minikube start

# Pause Kubernetes without impacting deployed applications.
minikube pause

# Unpause a paused instance.
minikube unpause

# Halt the cluster.
minikube stop

# Delete the cluster.
minikube delete

# Upgrade your cluster.
minikube start --kubernetes-version=latest

# Start another cluster.
minikube start -p cluster2

# Show the current active profile.
minikube profile

# List all profiles.
minikube profile list

# Switch the active profile.
minikube profile <profile-name>

Addons

# List all addons.
minikube addons list

# Enable an addon.
minikube addons enable <addon-name>

# Enable an addon at the cluster startup time.
minikube start --addons <addon-name>

# If an addon exposes a browser endpoint, you can quickly open it with.
minikube addons open <addon-name>

# Disable an addon.
minikube addons disable <addon-name>

Configs

# Set the memory limit (requires a restart).
minikube config set memory <size-in-bytes>

# Set the cpu limit (requires a restart).
minikube config set cpus <number-of-cores>

# Get the current config for a field (e.g., memory or cpu).
minikube config <field-name>

# Show the current config.
minikube config view

Dashboard

Minikube On Local

# Show the dashboard (if you are not using Minikube locally).
minikube dashboard

Minikube On Remote

# Get a dashboard url.
minikube dashboard --url

# Forward your port.
minikube kubectl proxy -- --address='0.0.0.0' --disable-filter=true

# Then your minikube dashboard can be accessed from the following url.
# (The following command can run from your Mac laptop. If you are not using a Mac laptop, copy the url to your browser)
open "http://{your-minikube-host-ip}:8001/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/"

Cheatsheets: Mongodb Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Install

ubuntu 22.04 (Jammy)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

ubuntu 20.04 (Focal)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

ubuntu 18.04 (Bionic)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

ubuntu 16.04 (Xenial)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

debian 11 (Bullseye)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb http://repo.mongodb.org/apt/debian bullseye/mongodb-org/6.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

debian 10 (Buster)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb http://repo.mongodb.org/apt/debian buster/mongodb-org/6.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

debian 9 (Stretch)

wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
echo "deb http://repo.mongodb.org/apt/debian stretch/mongodb-org/6.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update && sudo apt-get install -y mongodb-org

Uninstall

# Stop mongodb.
sudo service mongod stop

# Remove mongodb.
sudo apt-get purge mongodb-org*

# Remove data directory.
sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb

Mongodb Service Managament

# Start mongodb.
sudo systemctl start mongod

# If you see error like this "Failed to start mongod.service: Unit mongod.service not found.", run
sudo systemctl daemon-reload

# Enable mongodb as a service which starts after reboot.
sudo systemctl enable mongod

# Stop monogdb service.
sudo systemctl stop mongod

# Check mongodb service status.
sudo systemctl status mongod

# Restart mongodb.
sudo systemctl restart mongod

# Ping mongodb.
mongo --eval 'db.runCommand({ connectionStatus: 1 })'

# Connect to mongodb service from mongodb shell.
mongosh

DB Shell Commands

DB Commands

// Show all databases.
show dbs

// Show the current database.
db

// Create or switch database. (Replace db_name with yours)
use db_name

// Drop the current database.
db.dropDatabase()

Collection Commands

// Create collection. (Replace col_name with yours)
db.createCollection(col_name)

// Show collections.
show collections

// Insert one row. (Replace json with yours)
db.col_name.insert({
 key1: "value1",
 key2: "value2"
})

// Insert many rows. (Replace json with yours)
db.col_name.insertMany([
 {
 key1: "value1_1",
 key2: "value1_2"
 },
 {
 key1: "value2_1",
 key2: "value2_2"
 }
])

// Get all rows.
db.col_name.find()

// Get all rows formated.
db.col_name.find().pretty()

// Find one row.
db.col_name.findOne({
 key1: "value1"
})

// Find rows with specific fields.
db.col_name.find({ key1: "value1" }, {
 key1: 1,
 key2: 1
})

// Find rows.
db.col_name.find({
 key1: "value1"
})

// Update one row.
db.col_name.updateOne(
 { key1: "value1" },
 {
 "$set": {
 key1: "value1",
 key2: "value3"
 }
 },
 {
 upsert: true
 }
)

// Update many rows.
db.col_name.updateMany(
 { key1: "value1" },
 {
 "$set": {
 key1: "value1",
 key2: "value3"
 }
 },
 {
 upsert: true
 }
)

// Delete row.
db.col_name.remove({
 key1: "value1"
})

// Sort rows.
db.col_name.find().sort({ key1: 1 })

// Count rows.
db.col_name.find().count()

// Limit rows.
db.col_name.find().limit(2)

// For each.
db.col_name.find().forEach(function(obj) {
 print("Object: " + obj.key1)
})

// Create index.
db.col_name.createIndex({
 key1: 1
})

Files

File Path	File Use
`/etc/mongod.conf`	default config file path
`/var/log/mongodb/mongod.log`	default log file path

Cheatsheets: Npm Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

Init Project

# Initialize a project.
npm init

# Instantly initialize a project.
npm init --yes

Install Package

# Install all packages defined in package.json.
npm install

# An alias of npm install.
npm i

# Install a package.
npm install <package-name>

# Install a package. (Same as npm install <package-name> after npm 5.0.0)
npm install <package-name> --save

# Install a package as a dev dependency.
npm install <package-name> --dev-save

# Install a package globally.
npm install <package-name> -g

# Install a package of a specific version.
npm install <package-name>@<version>

# Install via github repo.
npm install <github-repo-url>

# Install via a file path.
npm install <file-path>

# Install via tar package over https, e.g., https://site.com/archive.tgz.
npm install <http-tar-package-url>

Uninstall

# Remove a package.
npm rm <package-name>

List And View Package

# List installed packages.
npm list

# An alias of npm list.
npm ls

# List globally installed packages.
npm list -g

# List outdated packages.
npm outdated

# List the latest versions of a package.
npm view <package-name>

Run

# Run a script defined in package.json.
npm run <script-name>

Cheatsheets: Proxmox Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

VM Management

Basics

# list VMs
qm list

# Create or restore a virtual machine.
qm create <vmid>

# Create or restore a virtual machine with core, memory, disks specified.
qm create <vmid> --name <vm-name> --cores <number-of-cores> --memory <memory-size-in-bytes> --scsi0 file=<vg-name>:<size-in-gb> --cdrom local:<iso-name> --net0 virtio,bridge=<bridge-name>

# start a VM
qm start <vmid>

# Suspend virtual machine.
qm suspend <vmid>

# shutdown a VM
qm shutdown <vmid>

# reboot a VM
qm reboot <vmid>

# reset a VM
qm reset <vmid>

# stop a VM
qm stop <vmid>

# Destroy the VM and all used/owned volumes.
# Removes any VM specific permissions and firewall rules
qm destroy <vmid>

# Enter Qemu Monitor interface.
qm monitor <vmid>

# Get the virtual machine configuration with both current and pending values.
qm pending <vmid>

# Send key event to virtual machine.
qm sendkey <vmid> <key> [OPTIONS]

# Show command line which is used to start the VM (debug info).
qm showcmd <vmid> [OPTIONS]

# Unlock the VM.
qm unlock <vmid>

# Clone a VM
qm clone <vmid> <newid>

# Clone a VM in full clone mode and also set the name.
qm clone <vmid> <newid> --full --name <name>

# Migrate a VM
qm migrate <vmid> <target-node>

# Show VM status
qm status <vmid>

# Clean up resources for a VM
qm cleanup <vmid> <clean-shutdown> <guest-requested>

# Create a Template.
qm template <vmid> [OPTIONS]

# Set virtual machine options (synchrounous API)
qm set <vmid> [OPTIONS]

Cloudinit

# Get automatically generated cloudinit config.
qm cloudinit dump <vmid> <type>

# Get the cloudinit configuration with both current and pending values.
qm cloudinit pending <vmid>

# Regenerate and change cloudinit config drive.
qm cloudinit update <vmid>

Disk

# Import an external disk image as an unused disk in a VM.
# The image format has to be supported by qemu-img(1).
qm disk import <vmid> <source> <storage>

# Move volume to different storage or to a different VM.
qm disk move <vmid> <disk> [<storage>] [OPTIONS]

# Rescan all storages and update disk sizes and unused disk images.
qm disk rescan [OPTIONS]

# Extend volume size.
qm disk resize <vmid> <disk> <size> [OPTIONS]

# Unlink/delete disk images.
qm disk unlink <vmid> --idlist <string> [OPTIONS]

# rescan volumes
qm rescan

Snapshot

# List all snapshots.
qm listsnapshot <vmid>

# Snapshot a VM
qm snapshot <vmid> <snapname>

# Delete a snapshot.
qm delsnapshot <vmid> <snapname>

# Rollback a snapshot
qm rollback <vmid> <snapname>

# Open a terminal using a serial device
# (The VM need to have a serial device configured, for example serial0: socket)
qm terminal <vmid> [OPTIONS]

# Proxy VM VNC traffic to stdin/stdout
qm vncproxy <vmid>

Others

# Execute Qemu Guest Agent commands.
qm guest cmd <vmid> <command>

# Executes the given command via the guest agent
qm guest exec <vmid> [<extra-args>] [OPTIONS]

# Gets the status of the given pid started by the guest-agent
qm guest exec-status <vmid> <pid>

# Sets the password for the given user to the given password
qm guest passwd <vmid> <username> [OPTIONS]

PV, VG & LV Management

# Create a PV
pvcreate <disk-device-name>

# Remove a PV
pvremove <disk-device-name>

# List all PVs
pvs

# Create a VG
vgcreate <vg-name> <disk-device-name>

# Remove a VG
vgremove <vg-name>

# List all VGs
vgs

# Create a LV
lvcreate -L <lv-size> -n <lv-name> <vg-name>

# Remove a LV
lvremove <vg-name>/<lv-name>

# List all LVs
lvs

Storage Management

# Create a new storage.
pvesm add <type> <storage> [OPTIONS]

# Allocate disk images.
pvesm alloc <storage> <vmid> <filename> <size> [OPTIONS]

# Delete volume
pvesm free <volume> [OPTIONS]

# Delete storage configuration.
pvesm remove <storage>

# List storage content.
pvesm list <storage> [OPTIONS]

# An alias for pvesm scan lvm.
pvesm lvmscan

# An alias for pvesm scan lvmthin.
pvesm lvmthinscan

# List local LVM volume groups.
pvesm scan lvm

# List local LVM Thin Pools.
pvesm scan lvmthin <vg>

# Get status for all datastores.
pvesm status [OPTIONS]

Template Management

# list all templates
pveam available

# list all templates
pveam list <storage>

# Download appliance templates
pveam download <storage> <template>

# Remove a template.
pveam remove <template-path>

# Update Container Template Database.
pveam update

Container Management

Basics

# List containers
pct list

# Create or restore a container.
pct create <vmid> <ostemplate> [OPTIONS]

# Start the container.
pct start <vmid> [OPTIONS]

# Create a container clone/copy
pct clone <vmid> <newid> [OPTIONS]

# Suspend the container. This is experimental.
pct suspend <vmid>

# Resume the container.
pct resume <vmid>

# Stop the container.
# This will abruptly stop all processes running in the container.
pct stop <vmid> [OPTIONS]

# Shutdown the container.
# This will trigger a clean shutdown of the container, see lxc-stop(1) for details.
pct shutdown <vmid> [OPTIONS]

# Destroy the container (also delete all uses files).
pct destroy <vmid> [OPTIONS]

# Show CT status.
pct status <vmid> [OPTIONS]

# Migrate the container to another node. Creates a new migration task.
pct migrate <vmid> <target> [OPTIONS]

# Get container configuration.
pct config <vmid> [OPTIONS]

# Print the list of assigned CPU sets.
pct cpusets

# Get container configuration, including pending changes.
pct pending <vmid>

# Reboot the container by shutting it down, and starting it again. Applies pending changes.
pct reboot <vmid> [OPTIONS]

# Create or restore a container.
pct restore <vmid> <ostemplate> [OPTIONS]

# Set container options.
pct set <vmid> [OPTIONS]

# Create a Template.
pct template <vmid>

# Unlock the VM.
pct unlock <vmid>

Disk

# Get the container’s current disk usage.
pct df <vmid>

# Run a filesystem check (fsck) on a container volume.
pct fsck <vmid> [OPTIONS]

# Run fstrim on a chosen CT and its mountpoints.
pct fstrim <vmid> [OPTIONS]

# Mount the container’s filesystem on the host.
# This will hold a lock on the container and is meant for emergency maintenance only
# as it will prevent further operations on the container other than start and stop.
pct mount <vmid>

# Move a rootfs-/mp-volume to a different storage or to a different container.
pct move-volume <vmid> <volume> [<storage>] [<target-vmid>] [<target-volume>] [OPTIONS]

# Unmount the container’s filesystem.
pct unmount <vmid>

# Resize a container mount point.
pct resize <vmid> <disk> <size> [OPTIONS]

# Rescan all storages and update disk sizes and unused disk images.
pct rescan [OPTIONS]

# Launch a console for the specified container.
pct console <vmid> [OPTIONS]

# Launch a shell for the specified container.
pct enter <vmid>

# Launch a command inside the specified container.
pct exec <vmid> [<extra-args>]

# Copy a file from the container to the local system.
pct pull <vmid> <path> <destination> [OPTIONS]

# Copy a local file to the container.
pct push <vmid> <file> <destination> [OPTIONS]

Snapshot

# Snapshot a container.
pct snapshot <vmid> <snapname> [OPTIONS]

# List all snapshots.
pct listsnapshot <vmid>

# Rollback LXC state to specified snapshot.
pct rollback <vmid> <snapname> [OPTIONS]

# Delete a LXC snapshot.
pct delsnapshot <vmid> <snapname> [OPTIONS]

Web GUI

# Restart web GUI
service pveproxy restart

Important File/Dir Path

PVE


`/etc/pve/authkey.pub`	Public key used by the ticket system
`/etc/pve/ceph.conf`	Ceph configuration file (note: /etc/ceph/ceph.conf is a symbolic link to this)
`/etc/pve/corosync.conf`	Corosync cluster configuration file (prior to Proxmox VE 4.x, this file was called cluster.conf)
`/etc/pve/datacenter.cfg`	Proxmox VE data center-wide configuration (keyboard layout, proxy, …)
`/etc/pve/domains.cfg`	Proxmox VE authentication domains
`/etc/pve/firewall/cluster.fw`	Firewall configuration applied to all nodes
`/etc/pve/firewall/<NAME>.fw`	Firewall configuration for individual nodes
`/etc/pve/firewall/<VMID>.fw`	Firewall configuration for VMs and containers
`/etc/pve/ha/crm_commands`	Displays HA operations that are currently being carried out by the CRM
`/etc/pve/ha/manager_status`	JSON-formatted information regarding HA services on the cluster
`/etc/pve/ha/resources.cfg`	Resources managed by high availability, and their current state
`/etc/pve/nodes/<NAME>/config`	Node-specific configuration
`/etc/pve/nodes/<NAME>/lxc/<VMID>.conf`	VM configuration data for LXC containers
`/etc/pve/nodes/<NAME>/openvz/`	Prior to PVE 4.0, used for container configuration data (deprecated, removed soon)
`/etc/pve/nodes/<NAME>/pve-ssl.key`	Private SSL key for pve-ssl.pem
`/etc/pve/nodes/<NAME>/pve-ssl.pem`	Public SSL certificate for web server (signed by cluster CA)
`/etc/pve/nodes/<NAME>/pveproxy-ssl.key`	Private SSL key for pveproxy-ssl.pem (optional)
`/etc/pve/nodes/<NAME>/pveproxy-ssl.pem`	Public SSL certificate (chain) for web server (optional override for pve-ssl.pem)
`/etc/pve/nodes/<NAME>/qemu-server/<VMID>.conf`	VM configuration data for KVM VMs
`/etc/pve/priv/authkey.key`	Private key used by ticket system
`/etc/pve/priv/authorized_keys`	SSH keys of cluster members for authentication
`/etc/pve/priv/ceph*`	Ceph authentication keys and associated capabilities
`/etc/pve/priv/known_hosts`	SSH keys of the cluster members for verification
`/etc/pve/priv/lock/*`	Lock files used by various services to ensure safe cluster-wide operations
`/etc/pve/priv/pve-root-ca.key`	Private key of cluster CA
`/etc/pve/priv/shadow.cfg`	Shadow password file for PVE Realm users
`/etc/pve/priv/storage/<STORAGE-ID>.pw`	Contains the password of a storage in plain text
`/etc/pve/priv/tfa.cfg`	Base64-encoded two-factor authentication configuration
`/etc/pve/priv/token.cfg`	API token secrets of all tokens
`/etc/pve/pve-root-ca.pem`	Public certificate of cluster CA
`/etc/pve/pve-www.key`	Private key used for generating CSRF tokens
`/etc/pve/sdn/*`	Shared configuration files for Software Defined Networking (SDN)
`/etc/pve/status.cfg`	Proxmox VE external metrics server configuration
`/etc/pve/storage.cfg`	Proxmox VE storage configuration
`/etc/pve/user.cfg`	Proxmox VE access control configuration (users/groups/…)
`/etc/pve/virtual-guest/cpu-models.conf`	For storing custom CPU models
`/etc/pve/vzdump.cron`	Cluster-wide vzdump backup-job schedule

Debug


`/etc/pve/.version`	file versions (to detect file modifications)
`/etc/pve/.members`	Info about cluster members
`/etc/pve/.vmlist`	List of all VMs
`/etc/pve/.clusterlog`	Cluster log (last 50 entries)
`/etc/pve/.rrd`	RRD data (most recent entries)

OpenVZ Section


`/etc/vz/conf/xxx.conf`	config
`/var/lib/vz/root/xxx`	data
`/var/lib/vz/template/cache`	template
`/var/lib/vz/dump`	snapshot
`/etc/vz/vz.conf`	OpenVZ config

KVM Section


`/var/lib/vz/images/xxx`	data
`/var/lib/vz/template/iso`	template
`/var/lib/vz/dump`	snapshot

LXC Section


`/var/lib/lxc/xxx/config`	config
`/var/lib/vz/images/xxx`	data
`/var/lib/vz/template/cache`	template
`/var/lib/vz/dump`	snapshot

Cheatsheets: Rust Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Installation

sudo apt update && sudo apt install cargo -y

Hello World

# Create a new project first.
cargo new hello_world

# Go to the project dir.
cd hello_world

# Compile the source code.
cargo build

# Run the code
cargo run

Source Code

The source code of the hello world program is

fn main() {
 println!("Hello, world!");
}

Basics

Variables

x : i32 = 1; // An i32 variable.

x : bool = true; // A boolean variable.

x : f32 = 1.2; // A float 32 variable.

All variable data types:

DataType	Description
`bool`	The boolean type.
`char`	A character type.
`i8`	The 8-bit signed integer type.
`i16`	The 16-bit signed integer type.
`i32`	The 32-bit signed integer type.
`i64`	The 64-bit signed integer type.
`isize`	The pointer-sized signed integer type.
`u8`	The 8-bit unsigned integer type.
`u16`	The 16-bit unsigned integer type.
`u32`	The 32-bit unsigned integer type.
`u64`	The 64-bit unsigned integer type.
`usize`	The pointer-sized unsigned integer type.
`f32`	The 32-bit floating point type.
`f64`	The 64-bit floating point type.
`array`	A fixed-size array, denoted [T; N], for the element type, T, and the non-negative compile-time constant size, N.
`slice`	A dynamically-sized view into a contiguous sequence, [T].
`str`	String slices.
`tuple`	A finite heterogeneous sequence, (T, U, ..).

Functions

pub fn foo(x: i32, y: i32) -> i32 {
 x + y
}

Control Flow

If

if x > 0 {
 ...
} else {
 ...
}

Loops

// For loop.
for i in iterator {
 ...
}

// While loop.
let i = 0
while i < 10 {
 ...
 i += 1;
}

Structs And Traits

// Defining structs.
pub struct Base {
 a: i32,
 b: i32,
 c: i32,
}

pub struct Derived1 {
 base: Base,
 d: i32,
}

pub struct Derived2 {
 base: Base,
 e: i32,
}

// Defining traits.
pub trait BaseTrait {
 fn a(&self) -> i32;
 fn b(&self) -> i32;
 fn c(&self) -> i32;
}

pub trait Derived1Trait : BaseTrait {
 fn d(&self) -> i32;
}

pub trait Derived2Trait : BaseTrait {
 fn e(&self) -> i32;
}

// Implementations.
impl BaseTrait for Derived1 {
 fn a(&self) -> i32 { self.base.a }
 fn b(&self) -> i32 { self.base.b }
 fn c(&self) -> i32 { self.base.c }
}

impl Derived1Trait for Derived1 {
 fn d(&self) -> i32 { self.d }
}

impl BaseTrait for Derived2 {
 fn a(&self) -> i32 { self.base.a }
 fn b(&self) -> i32 { self.base.b }
 fn c(&self) -> i32 { self.base.c }
}

impl Derived2Trait for Derived2 {
 fn e(&self) -> i32 { self.e }
}

Enums

enum IpAddrKind {
 V4,
 V6,
}

References

let data: DataType = DataType::new();

// Create a reference.
let data_ref: &DataType = &data;

// Create a mutable reference.
let mut data_mut_ref: &DataType = &data;

Smart Pointers

Smart pointers allow us to define data on heap instead of stack.

Box<T>

Define a single owner smart pointer.

let data: Box<DataType> = Box::new(DataType::new());

Rc<T>

Define a multi-owners smart pointer.

use std::rc::Rc;
let data: Rc<DataType> = Rc::new(DataType::new());

Ref<T> and RefCell<T>

use std::rc::Rc;
use std::cell::RefCell;

let data: Box<RefCell<DataType>> = Box::new(RefCell::new(DataType::new()));

// Get a reference.
let data_ref = data.borrow();

// Get an immutable reference.
let data_mut_ref = data.borrow_mut();

Common Data Structures

Vector<T>

let mut vec = Vec::new();
vec.push(1);
vec.push(2);

assert_eq!(vec.len(), 2);
assert_eq!(vec[0], 1);

assert_eq!(vec.pop(), Some(2));
assert_eq!(vec.len(), 1);

vec[0] = 7;
assert_eq!(vec[0], 7);

vec.extend([1, 2, 3]);

for x in &vec {
 println!("{x}");
}
assert_eq!(vec, [7, 1, 2, 3]);

HashMap<K, V>

use std::collections::HashMap;

// Type inference lets us omit an explicit type signature (which
// would be `HashMap<String, String>` in this example).
let mut book_reviews = HashMap::new();

// Review some books.
book_reviews.insert(
 "Adventures of Huckleberry Finn".to_string(),
 "My favorite book.".to_string(),
);
book_reviews.insert(
 "Grimms' Fairy Tales".to_string(),
 "Masterpiece.".to_string(),
);
book_reviews.insert(
 "Pride and Prejudice".to_string(),
 "Very enjoyable.".to_string(),
);
book_reviews.insert(
 "The Adventures of Sherlock Holmes".to_string(),
 "Eye lyked it alot.".to_string(),
);

// Check for a specific one.
// When collections store owned values (String), they can still be
// queried using references (&str).
if !book_reviews.contains_key("Les Misérables") {
 println!("We've got {} reviews, but Les Misérables ain't one.",
 book_reviews.len());
}

// oops, this review has a lot of spelling mistakes, let's delete it.
book_reviews.remove("The Adventures of Sherlock Holmes");

// Look up the values associated with some keys.
let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];
for &book in &to_find {
 match book_reviews.get(book) {
 Some(review) => println!("{book}: {review}"),
 None => println!("{book} is unreviewed.")
 }
}

// Look up the value for a key (will panic if the key is not found).
println!("Review for Jane: {}", book_reviews["Pride and Prejudice"]);

// Iterate over everything.
for (book, review) in &book_reviews {
 println!("{book}: \"{review}\"");
}

Queue<T>

// Create a simple Queue
let mut q: Queue<isize> = queue![];

// Add some elements to it
q.add(1);
q.add(-2);
q.add(3);

// Check the Queue's size
q.size(); // 3

// Remove an element
q.remove(); // Ok(1)

// Check the Queue's size
q.size(); // 2

// Peek at the next element scheduled for removal
q.peek(); // Ok(-2)

// Confirm that the Queue size hasn't changed
q.size(); // 2

// Remove the remaining elements
q.remove(); // Ok(-2)
q.remove(); // Ok(3)

// Peek into an empty Queue
q.peek(); // Raises an error

// Attempt to remove an element from an empty Queue
q.remove(); // Raises an error
 ```

Cheatsheets: Tensorflow Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Install Tensorflow

# Upgrade pip
pip install --upgrade pip

# Install the current stable release of tensorflow.
pip install tensorflow

Tensorflow APIs

Tensor

# Define a constant tensor.
tf.constant(5)

# Define another constant tensor.
tf.constant([[1.0, 2.0], [3.0, 4.0]])

# Compute a tensor from two constant tensors.
t1 = tf.constant([[1.0, 2.0], [3.0, 4.0]])
t2 = tf.constant([[1.0, 1.0], [0.0, 1.0]])
t3 = tf.matmul(t1, t2)

# Get the tensor device.
t.device

# Get DType of the tensor.
t.dtype

# Get the tensor name.
t.name

# Get the graph containing this tensor.
t.graph

# Get the Operation that produces this tensor as an output.
t.op

# Get the tensor shape.
t.shape

# Get the index of this tensor in the outputs of its Operation.
t.value_index

RaggedTensor

# The tensor value is <tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
tf.RaggedTensor.from_row_splits(
 values=[3, 1, 4, 1, 5, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]
)

# The tensor value is <tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
tf.RaggedTensor.from_row_lengths(
 values=[3, 1, 4, 1, 5, 9, 2, 6], row_lengths=[4, 0, 3, 1, 0]
)

# The tensor value is <tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
tf.RaggedTensor.from_value_rowids(
 values=[3, 1, 4, 1, 5, 9, 2, 6], value_rowids=[0, 0, 0, 0, 2, 2, 2, 3], nrows=5
)

# The tensor value is <tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
tf.RaggedTensor.from_row_starts(
 values=[3, 1, 4, 1, 5, 9, 2, 6], row_starts=[0, 4, 4, 7, 8]
)

# The tensor value is <tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], []]>
tf.RaggedTensor.from_row_limits(
 values=[3, 1, 4, 1, 5, 9, 2, 6], row_limits=[4, 4, 7, 8, 8]
)

# The tensor value is <tf.RaggedTensor [[3, 1], [4, 1], [5, 9], [2, 6]]>
tf.RaggedTensor.from_uniform_row_length(
 values=[3, 1, 4, 1, 5, 9, 2, 6], uniform_row_length=2
)

SparseTensor

# Defines a sparse tensor representing the following dense tensor:
# [[1, 0, 0, 0]
# [0, 0, 2, 0]
# [0, 0, 0, 0]]
SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4])

Variable

# Create a variable.
v = tf.Variable(1.)

# Assign 2.0 to the variable.
v.assign(2.)

# Add 0.5 to the variable.
v.assign_add(0.5)

# Substract 0.5 from the variable.
v.assign_sub(0.5)

# Matmul a variable and a constant tensor.
w = tf.Variable([[1.], [2.]])
x = tf.constant([[3., 4.]])
tf.matmul(w, x)

# Variable can only be created once within a tf.function.
class M(tf.Module):
 @tf.function
 def __call__(self, x):
 if not hasattr(self, "v"): # Or set self.v to None in __init__
 self.v = tf.Variable(x)
 return self.v * x

tf.data

# Load dataset using range.
tf.data.Dataset.range(5) # [0, 1, 2, 3, 4]
tf.data.Dataset.range(2, 5) # [2, 3, 4]
tf.data.Dataset.range(1, 5, 2) # [1, 3]
tf.data.Dataset.range(1, 5, -2) # []
tf.data.Dataset.range(5, 1) # []
tf.data.Dataset.range(5, 1, -2) # [5, 3]
tf.data.Dataset.range(2, 5, output_type=tf.int32) # [2, 3, 4]
tf.data.Dataset.range(1, 5, 2, output_type=tf.float32) # [1.0, 3.0]

# Load tf data from python array
dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])

# Load dataset from txt files.
dataset = tf.data.TextLineDataset(["file1.txt", "file2.txt"])

# Load data from tfrecords files.
dataset = tf.data.TFRecordDataset(["file1.tfrecords", "file2.tfrecords"])

# Create a dataset using all files matching a pattern.
dataset = tf.data.Dataset.list_files("/path/*.txt")

# Split dataset into batches.
dataset = tf.data.Dataset.range(8)
dataset = dataset.batch(3) # The dataset value is [[0, 1, 2], [3, 4, 5], [6, 7]]

# Transform a dataset.
dataset = dataset.map(lambda x: x*2)

# Prefetch a dataset.
dataset = tf.data.Dataset.range(3)
dataset = dataset.prefetch(2)

# Repeat a dataset.
dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
dataset = dataset.repeat(3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# Shuttle a dataset.
dataset = tf.data.Dataset.range(3)
dataset = dataset.shuffle(3, reshuffle_each_iteration=False)
dataset = dataset.repeat(2) # [1, 0, 2, 1, 0, 2]

# Concat a dataset.
a = tf.data.Dataset.range(1, 4) # [1, 2, 3]
b = tf.data.Dataset.range(4, 8) # [4, 5, 6, 7]
ds = a.concatenate(b) # [1, 2, 3, 4, 5, 6, 7]

# Zip two datasets.
a = tf.data.Dataset.range(1, 4) # [1, 2, 3]
b = tf.data.Dataset.range(4, 7) # [4, 5, 6]
ds = tf.data.Dataset.zip((a, b)) # [(1, 4), (2, 5), (3, 6)]

# Iterating data in tf.data.
for element in dataset:
 print(element)

tf.math

# Get absolute values.
x = tf.constant([-2.25, 3.25])
tf.abs(x) # [2.25, 3.25]

# Add a scalar and a list.
tf.add([1, 2, 3, 4, 5], 1) # [2, 3, 4, 5, 6]

# Add two tensors.
x = tf.convert_to_tensor([1, 2, 3, 4, 5])
y = tf.convert_to_tensor(1)
z = x + y # [2, 3, 4, 5, 6]

# Add a list and a tensor.
x = [1, 2, 3, 4, 5]
y = tf.constant([1, 2, 3, 4, 5])
tf.add(x, y)

# Add n tensors.
a = tf.constant([[3, 5], [4, 8]])
b = tf.constant([[1, 6], [2, 9]])
tf.math.add_n([a, b, a]) # [[7, 16], [10, 25]]

# Get the cumulative sum.
x = tf.constant([2, 4, 6, 8])
tf.cumsum(x) # [2, 6, 12, 20]

# Get the cumulative sum for certain axis.
y = tf.constant([[2, 4, 6, 8], [1, 3, 5, 7]])
tf.cumsum(y, axis=0) # [[2, 4, 6, 8], [3, 7, 11, 15]]
tf.cumsum(y, axis=1) # [[2, 6, 12, 20], [1, 4, 9, 16]]

# Get the exclusive cumulative sum.
x = tf.constant([2, 4, 6, 8])
tf.cumsum(x, exclusive=True) # [0, 2, 6, 12]

# Get the reverse cumulative sum.
x = tf.constant([2, 4, 6, 8])
tf.cumsum(x, reverse=True) # [18, 14, 8, 0]

# Divide tensors.
x = tf.constant([16, 12, 11])
y = tf.constant([4, 6, 2])
tf.divide(x, y) # [4.0, 2.0, 5.5]

# Get tensor equals.
x = tf.constant([2, 4])
y = tf.constant(2)
tf.math.equal(x, y) # [True, False]

# Get tensor equals.
x = tf.constant([2, 4])
y = tf.constant([2, 4])
tf.math.equal(x, y) # [True, True]

# Multiply tensors.
x = tf.constant(([1, 2, 3, 4]))
tf.math.multiply(x, x) # [1, 4, 9, 16]

# Multiple tensors of different shapes with broadcast.
x = tf.ones([1, 2]);
y = tf.ones([2, 1]);
x * y # [[1.0, 1.0], [1.0, 1.0]]

# Compute the power of one value to another.
x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf.pow(x, y) # [[256, 65536], [9, 27]]

# Compute sigmoid of a tensor.
x = tf.constant([0.0, 1.0, 50.0, 100.0])
tf.math.sigmoid(x) # [0.5, 0.7310586, 1.0, 1.0]

tf.linalg

# Transpose a matrix.
x = tf.constant([[1, 2, 3], [4, 5, 6]])
tf.linalg.matrix_transpose(x) # [[1, 4], [2, 5], [3, 6]]

# Matmul two tensors.
a = tf.constant([[1, 2, 3], [4, 5, 6]])
b = tf.constant([[7, 8], [9, 10], [11, 12]])
c = tf.matmul(a, b) # [[58, 64], [139, 154]]

tf.distribute

################################################################################
# Define a mirrored strategy, and create a variable in it.
# The variable will be mirrored on both GPU:0 and GPU:1.
################################################################################
strategy = tf.distribute.MirroredStrategy(["GPU:0", "GPU:1"])
with strategy.scope():
 x = tf.Variable(1.)


################################################################################
# Variables (e.g., x in this example) created in tf.function is still mirrored.
################################################################################
x = []
@tf.function # Wrap the function with tf.function.
def create_variable():
 if not x:
 x.append(tf.Variable(1.))
 return x[0]
strategy = tf.distribute.MirroredStrategy(["GPU:0", "GPU:1"])
with strategy.scope():
 _ = create_variable()


################################################################################
# Dataset can also be mirrored to multiple devices within the MirroredStrategy.
################################################################################
my_strategy = tf.distribute.MirroredStrategy()
with my_strategy.scope():
 @tf.function
 def distribute_train_epoch(dataset):
 def replica_fn(input):
 # process input and return result
 return result

 total_result = 0
 for x in dataset:
 per_replica_result = my_strategy.run(replica_fn, args=(x,))
 total_result += my_strategy.reduce(tf.distribute.ReduceOp.SUM,
 per_replica_result, axis=None)
 return total_result

 dist_dataset = my_strategy.experimental_distribute_dataset(dataset)
 for _ in range(EPOCHS):
 train_result = distribute_train_epoch(dist_dataset)


################################################################################
# MultiWorkerMirroredStrategy is used for distributed training.
################################################################################
strategy = tf.distribute.MultiWorkerMirroredStrategy()

@tf.function
def train_step(iterator):
 def step_fn(inputs):
 features, labels = inputs
 with tf.GradientTape() as tape:
 logits = model(features, training=True)
 loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits)

 grads = tape.gradient(loss, model.trainable_variables)
 optimizer.apply_gradients(zip(grads, model.trainable_variables))

 strategy.run(step_fn, args=(next(iterator),))

for _ in range(NUM_STEP):
 train_step(iterator)


################################################################################
# Use TPUStrategy to train a model on TPUs.
################################################################################
resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
 model = tf.keras.Sequential([tf.keras.layers.Dense(2, input_shape=(5,))])
 optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)

def dataset_fn(ctx):
 x = np.random.random((2, 5)).astype(np.float32)
 y = np.random.randint(2, size=(2, 1))
 dataset = tf.data.Dataset.from_tensor_slices((x, y))
 return dataset.repeat().batch(1, drop_remainder=True)

dist_dataset = strategy.distribute_datasets_from_function(dataset_fn)
iterator = iter(dist_dataset)

@tf.function()
def train_step(iterator):
 def step_fn(inputs):
 features, labels = inputs
 with tf.GradientTape() as tape:
 logits = model(features, training=True)
 loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits)

 grads = tape.gradient(loss, model.trainable_variables)
 optimizer.apply_gradients(zip(grads, model.trainable_variables))

 strategy.run(step_fn, args=(next(iterator),))

train_step(iterator)

tf.saved_model

# Define a tf module.
class Adder(tf.Module):
 @tf.function(input_signature=[tf.TensorSpec(shape=[], dtype=tf.float32)])
 def add(self, x):
 return x + x

# Save the tf module as our model.
model = Adder()
tf.saved_model.save(model, '/tmp/adder')

# Load the model.
loaded_model = tf.saved_model.load('/tmp/adder')
loaded_model.add(1.) # Returns a tensor with a value of 2.0.

tf.keras

Model

# Defining a keras model.
import tensorflow as tf

class MyModel(tf.keras.Model):

 def __init__(self):
 super().__init__()
 self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
 self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

 def call(self, inputs):
 x = self.dense1(inputs)
 return self.dense2(x)

model = MyModel()

Sequential

# Optionally, the first layer can receive an `input_shape` argument:
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8, input_shape=(16,)))
# Afterwards, we do automatic shape inference:
model.add(tf.keras.layers.Dense(4))

# This is identical to the following:
model = tf.keras.Sequential()
model.add(tf.keras.Input(shape=(16,)))
model.add(tf.keras.layers.Dense(8))

# Note that you can also omit the `input_shape` argument.
# In that case the model doesn't have any weights until the first call
# to a training/evaluation method (since it isn't yet built):
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
# model.weights not created yet

# Whereas if you specify the input shape, the model gets built
# continuously as you are adding layers:
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8, input_shape=(16,)))
model.add(tf.keras.layers.Dense(4))
len(model.weights) # Returns "4"

# When using the delayed-build pattern (no input shape specified), you can
# choose to manually build your model by calling
# `build(batch_input_shape)`:
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(4))
model.build((None, 16))
len(model.weights) # Returns "4"

# Note that when using the delayed-build pattern (no input shape specified),
# the model gets built the first time you call `fit`, `eval`, or `predict`,
# or the first time you call the model on some input data.
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(8))
model.add(tf.keras.layers.Dense(1))
model.compile(optimizer='sgd', loss='mse')
# This builds the model for the first time:
model.fit(x, y, batch_size=32, epochs=10)

Layers

# Define a relu activation layer.
layer = tf.keras.layers.Activation('relu')
output = layer([-3.0, -1.0, 0.0, 2.0]) # [0.0, 0.0, 0.0, 2.0]

# Define an Add layer.
input_shape = (2, 3, 4)
x1 = tf.random.normal(input_shape)
x2 = tf.random.normal(input_shape)
y = tf.keras.layers.Add()([x1, x2]) # the shape of y is (2, 3, 4)

# Define an Average layer.
x1 = np.ones((2, 2))
x2 = np.zeros((2, 2))
y = tf.keras.layers.Average()([x1, x2]) # [[0.5, 0.5], [0.5, 0.5]]

# Define an AveragePooling1D layer.
x = tf.constant([1., 2., 3., 4., 5.])
x = tf.reshape(x, [1, 5, 1])
avg_pool_1d = tf.keras.layers.AveragePooling1D(pool_size=2, strides=1, padding='valid')
avg_pool_1d(x) # [[[1.5], [2.5], [3.5], [4.5]]]

# Define a Concatenate layer.
x = np.arange(20).reshape(2, 2, 5)
y = np.arange(20, 30).reshape(2, 1, 5)
z = tf.keras.layers.Concatenate(axis=1)([x, y]) # the shape of z is (2, 3, 5)

# Define a Conv1D layer.
# The inputs are 128-length vectors with 10 timesteps, and the batch size is 4.
input_shape = (4, 10, 128)
x = tf.random.normal(input_shape)
y = tf.keras.layers.Conv1D(32, 3, activation='relu', input_shape=input_shape[1:])(x) # the shape of y is (4, 8, 32)

# Define a Conv2D layer.
input_shape = (4, 28, 28, 3)
x = tf.random.normal(input_shape)
y = tf.keras.layers.Conv2D(2, 3, activation='relu', input_shape=input_shape[1:])(x) # the shape of y is (4, 26, 26, 2)

# Define a Conv3D layer.
input_shape =(4, 28, 28, 28, 1)
x = tf.random.normal(input_shape)
y = tf.keras.layers.Conv3D(2, 3, activation='relu', input_shape=input_shape[1:])(x) # the shape of y is (4, 26, 26, 26, 2)

# Define a Dense layer with relu as its activation function.
tf.keras.layers.Dense(32, activation='relu'))

# Define a Dropout layer with a 20% drop rate.
tf.keras.layers.Dropout(.2, input_shape=(2,))

# Define an Embedding layer with an input dimension of 1000 and output dimension of 64.
tf.keras.layers.Embedding(1000, 64, input_length=10)

# Define a Flatten layer.
Flatten()

# Define a Hashing layer with 32 bins.
tf.keras.layers.Hashing(num_bins=32)

# Define a four-units LSTM layer.
tf.keras.layers.LSTM(4)

# Define a string look-up layer.
vocab = ["a", "b", "c", "d"]
data = tf.constant([["a", "c", "d"], ["d", "z", "b"]])
layer = tf.keras.layers.StringLookup(vocabulary=vocab)
layer(data) # Returns [[1, 3, 4], [4, 0, 2]]

Save & Load

# Define a model.
model = tf.keras.Sequential(
 [tf.keras.layers.Dense(5, input_shape=(3,)),
 tf.keras.layers.Softmax()]
)

# Save the model to /tmp/model.
model.save_model('/tmp/model') # Or model.save('/tmp/model')

# Load the model back from /tmp/model
loaded_model = tf.keras.models.load_model('/tmp/model')

Example Model Training Pipelines

A Sequential Model Training Pipeline

import tensorflow as tf
import tensorflow.keras.datasets.mnist as mnist

# Load training data.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Construct the model.
model = tf.keras.models.Sequential([
 tf.keras.layers.Flatten(input_shape=(28, 28)),
 tf.keras.layers.Dense(128, activation='relu'),
 tf.keras.layers.Dropout(0.2),
 tf.keras.layers.Dense(10)
])

# Define the loss function.
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Compile the model.
model.compile(optimizer='adam', loss=loss_fn, metrics=['accuracy'])

# Train the model.
model.fit(x_train, y_train, epochs=5)

# Evaluate the model.
model.evaluate(x_test, y_test, verbose=2)

A Custom Model Training Pipeline

import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model

# Get dataset.
mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Add a channels dimension
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")

# Process dataset with tf.data.
train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(10000).batch(32)
test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

# Define the model.
class MyModel(Model):
 def __init__(self):
 super(MyModel, self).__init__()
 self.conv1 = Conv2D(32, 3, activation='relu')
 self.flatten = Flatten()
 self.d1 = Dense(128, activation='relu')
 self.d2 = Dense(10)

 def call(self, x):
 x = self.conv1(x)
 x = self.flatten(x)
 x = self.d1(x)
 return self.d2(x)

# Create an instance of the model
model = MyModel()

# Define loss function.
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Define optimizer.
optimizer = tf.keras.optimizers.Adam()

# Define train loss and accuracy.
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

# Define test loss and accuracy.
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

# Define the train step with tf.function.
@tf.function
def train_step(images, labels):
 with tf.GradientTape() as tape:
 # training=True is only needed if there are layers with different
 # behavior during training versus inference (e.g. Dropout).
 predictions = model(images, training=True)
 loss = loss_object(labels, predictions)
 gradients = tape.gradient(loss, model.trainable_variables)
 optimizer.apply_gradients(zip(gradients, model.trainable_variables))

 train_loss(loss)
 train_accuracy(labels, predictions)

# Define the test step with tf.function.
@tf.function
def test_step(images, labels):
 # training=False is only needed if there are layers with different
 # behavior during training versus inference (e.g. Dropout).
 predictions = model(images, training=False)
 t_loss = loss_object(labels, predictions)

 test_loss(t_loss)
 test_accuracy(labels, predictions)

# Train and evaluate the model.
for epoch in range(4):
 # Reset the metrics at the start of the next epoch
 train_loss.reset_states()
 train_accuracy.reset_states()
 test_loss.reset_states()
 test_accuracy.reset_states()

 for images, labels in train_ds:
 train_step(images, labels)

 for test_images, test_labels in test_ds:
 test_step(test_images, test_labels)

 print(
 f'Epoch {epoch + 1}, '
 f'Loss: {train_loss.result()}, '
 f'Accuracy: {train_accuracy.result() * 100}, '
 f'Test Loss: {test_loss.result()}, '
 f'Test Accuracy: {test_accuracy.result() * 100}'
 )

Cheatsheets: Terminal Escape Code Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Control Escape Codes

Key Name	Escape Code
`S-up`	`\x1b[1;2A`
`S-down`	`\x1b[1;2B`
`S-right`	`\x1b[1;2C`
`S-left`	`\x1b[1;2D`
`S-end`	`\x1b[1;2F`
`S-home`	`\x1b[1;2H`
`M-up`	`\x1b[1;3A`
`M-down`	`\x1b[1;3B`
`M-right`	`\x1b[1;3C`
`M-left`	`\x1b[1;3D`
`M-end`	`\x1b[1;3F`
`M-home`	`\x1b[1;3H`
`M-S-up`	`\x1b[1;4A`
`M-S-down`	`\x1b[1;4B`
`M-S-right`	`\x1b[1;4C`
`M-S-left`	`\x1b[1;4D`
`M-S-end`	`\x1b[1;4F`
`M-S-home`	`\x1b[1;4H`
`C-up`	`\x1b[1;5A`
`C-down`	`\x1b[1;5B`
`C-right`	`\x1b[1;5C`
`C-left`	`\x1b[1;5D`
`C-end`	`\x1b[1;5F`
`C-home`	`\x1b[1;5H`
`C-S-up`	`\x1b[1;6A`
`C-S-down`	`\x1b[1;6B`
`C-S-right`	`\x1b[1;6C`
`C-S-left`	`\x1b[1;6D`
`C-S-end`	`\x1b[1;6F`
`C-S-home`	`\x1b[1;6H`
`C-M-up`	`\x1b[1;7A`
`C-M-down`	`\x1b[1;7B`
`C-M-right`	`\x1b[1;7C`
`C-M-left`	`\x1b[1;7D`
`C-M-end`	`\x1b[1;7F`
`C-M-home`	`\x1b[1;7H`
`C-M-S-up`	`\x1b[1;8A`
`C-M-S-down`	`\x1b[1;8B`
`C-M-S-right`	`\x1b[1;8C`
`C-M-S-left`	`\x1b[1;8D`
`C-M-S-end`	`\x1b[1;8F`
`C-M-S-home`	`\x1b[1;8H`
`M-insert`	`\x1b[2;3~`
`M-S-insert`	`\x1b[2;4~`
`C-insert`	`\x1b[2;5~`
`C-S-insert`	`\x1b[2;6~`
`C-M-insert`	`\x1b[2;7~`
`C-M-S-insert`	`\x1b[2;8~`
`S-delete`	`\x1b[3;2~`
`M-delete`	`\x1b[3;3~`
`M-S-delete`	`\x1b[3;4~`
`C-delete`	`\x1b[3;5~`
`C-S-delete`	`\x1b[3;6~`
`C-M-delete`	`\x1b[3;7~`
`C-M-S-delete`	`\x1b[3;8~`
`S-prior`	`\x1b[5;2~`
`M-prior`	`\x1b[5;3~`
`M-S-prior`	`\x1b[5;4~`
`C-prior`	`\x1b[5;5~`
`C-S-prior`	`\x1b[5;6~`
`C-M-prior`	`\x1b[5;7~`
`C-M-S-prior`	`\x1b[5;8~`
`S-next`	`\x1b[6;2~`
`M-next`	`\x1b[6;3~`
`M-S-next`	`\x1b[6;4~`
`C-next`	`\x1b[6;5~`
`C-S-next`	`\x1b[6;6~`
`C-M-next`	`\x1b[6;7~`
`C-M-S-next`	`\x1b[6;8~`
`C-backspace`	`\x1b[127;5u`
`C-M-return`	`\x1b[13;13u`
`S-return`	`\x1b[13;2u`
`C-return`	`\x1b[13;5u`
`C-S-return`	`\x1b[13;6u`
`C-M-tab`	`\x1b[9;13u`
`[S-tab`	`\x1b[9;2u`
`[C-tab`	`\x1b[9;5u`
`[C-S-tab`	`\x1b[9;6u`
`C-M-S-1`	`\x1b[33;14u`
`C-S-1`	`\x1b[33;6u`
`C-M-\`	`\x1b[34;14u`
`C-\`	`\x1b[34;6u`
`C-M-S-3`	`\x1b[35;14u`
`C-S-3`	`\x1b[35;6u`
`C-M-S-4`	`\x1b[36;14u`
`C-S-4`	`\x1b[36;6u`
`C-M-S-5`	`\x1b[37;14u`
`C-S-5`	`\x1b[37;6u`
`C-M-S-7`	`\x1b[38;14u`
`C-S-7`	`\x1b[38;6u`
`C-M-'`	`\x1b[39;13u`
`C-'`	`\x1b[39;5u`
`C-M-S-9`	`\x1b[40;14u`
`C-S-9`	`\x1b[40;6u`
`C-M-S-0`	`\x1b[41;14u`
`C-S-0`	`\x1b[41;6u`
`C-M-S-8`	`\x1b[42;14u`
`C-S-8`	`\x1b[42;6u`
`C-M-S-=`	`\x1b[43;14u`
`C-S-=`	`\x1b[43;6u`
`C-M-,`	`\x1b[44;13u`
`C-,`	`\x1b[44;5u`
`C-M-.`	`\x1b[46;13u`
`C-.`	`\x1b[46;5u`
`C-M-/`	`\x1b[47;13u`
`C-/`	`\x1b[47;5u`
`C-M-0`	`\x1b[48;13u`
`C-0`	`\x1b[48;5u`
`C-M-1`	`\x1b[49;13u`
`C-1`	`\x1b[49;5u`
`C-M-2`	`\x1b[50;13u`
`C-2`	`\x1b[50;5u`
`C-M-3`	`\x1b[51;13u`
`C-3`	`\x1b[51;5u`
`C-M-4`	`\x1b[52;13u`
`C-4`	`\x1b[52;5u`
`C-M-5`	`\x1b[53;13u`
`C-5`	`\x1b[53;5u`
`C-M-6`	`\x1b[54;13u`
`C-6`	`\x1b[54;5u`
`C-M-7`	`\x1b[55;13u`
`C-7`	`\x1b[55;5u`
`C-M-8`	`\x1b[56;13u`
`C-8`	`\x1b[56;5u`
`C-M-9`	`\x1b[57;13u`
`C-9`	`\x1b[57;5u`
`C-M-:`	`\x1b[58;14u`
`C-:`	`\x1b[58;6u`
`C-M-;`	`\x1b[59;13u`
`C-;`	`\x1b[59;5u`
`C-M-S-,`	`\x1b[60;14u`
`C-S-,`	`\x1b[60;6u`
`C-M-=`	`\x1b[61;13u`
`C-=`	`\x1b[61;5u`
`C-M-S-.`	`\x1b[62;14u`
`C-S-.`	`\x1b[62;6u`
`C-M-\\`	`\x1b[92;13u`

8 Color Escape Codes

Name	Hex Color Code	Foreground Escape Code	Background Escape Code
Black	`#000000`	`\x1b[1;30m`	`\x1b[1;40m`
Red	`#cc0000`	`\x1b[1;31m`	`\x1b[1;41m`
Green	`#4e9a06`	`\x1b[1;32m`	`\x1b[1;42m`
Yellow	`#c4a000`	`\x1b[1;33m`	`\x1b[1;43m`
Blue	`#729fcf`	`\x1b[1;34m`	`\x1b[1;44m`
Magenta	`#75507b`	`\x1b[1;35m`	`\x1b[1;45m`
Cyan	`#06989a`	`\x1b[1;36m`	`\x1b[1;46m`
White	`#d3d7cf`	`\x1b[1;37m`	`\x1b[1;47m`
Default		`\x1b[1;39m`	`\x1b[1;49m`

256 Color Escape Codes

	Name	Hex Color Code	Foreground Escape Code	Background Escape Code
0	Black (SYSTEM)	`#000000`	`\x1b[38:5:0m`	`\x1b[48:5:0m`
1	Maroon (SYSTEM)	`#800000`	`\x1b[38:5:1m`	`\x1b[48:5:1m`
2	Green (SYSTEM)	`#008000`	`\x1b[38:5:2m`	`\x1b[48:5:2m`
3	Olive (SYSTEM)	`#808000`	`\x1b[38:5:3m`	`\x1b[48:5:3m`
4	Navy (SYSTEM)	`#000080`	`\x1b[38:5:4m`	`\x1b[48:5:4m`
5	Purple (SYSTEM)	`#800080`	`\x1b[38:5:5m`	`\x1b[48:5:5m`
6	Teal (SYSTEM)	`#008080`	`\x1b[38:5:6m`	`\x1b[48:5:6m`
7	Silver (SYSTEM)	`#c0c0c0`	`\x1b[38:5:7m`	`\x1b[48:5:7m`
8	Grey (SYSTEM)	`#808080`	`\x1b[38:5:8m`	`\x1b[48:5:8m`
9	Red (SYSTEM)	`#ff0000`	`\x1b[38:5:9m`	`\x1b[48:5:9m`
10	Lime (SYSTEM)	`#00ff00`	`\x1b[38:5:10m`	`\x1b[48:5:10m`
11	Yellow (SYSTEM)	`#ffff00`	`\x1b[38:5:11m`	`\x1b[48:5:11m`
12	Blue (SYSTEM)	`#0000ff`	`\x1b[38:5:12m`	`\x1b[48:5:12m`
13	Fuchsia (SYSTEM)	`#ff00ff`	`\x1b[38:5:13m`	`\x1b[48:5:13m`
14	Aqua (SYSTEM)	`#00ffff`	`\x1b[38:5:14m`	`\x1b[48:5:14m`
15	White (SYSTEM)	`#ffffff`	`\x1b[38:5:15m`	`\x1b[48:5:15m`
16	Grey0	`#000000`	`\x1b[38:5:16m`	`\x1b[48:5:16m`
17	NavyBlue	`#00005f`	`\x1b[38:5:17m`	`\x1b[48:5:17m`
18	DarkBlue	`#000087`	`\x1b[38:5:18m`	`\x1b[48:5:18m`
19	Blue3	`#0000af`	`\x1b[38:5:19m`	`\x1b[48:5:19m`
20	Blue3	`#0000d7`	`\x1b[38:5:20m`	`\x1b[48:5:20m`
21	Blue1	`#0000ff`	`\x1b[38:5:21m`	`\x1b[48:5:21m`
22	DarkGreen	`#005f00`	`\x1b[38:5:22m`	`\x1b[48:5:22m`
23	DeepSkyBlue4	`#005f5f`	`\x1b[38:5:23m`	`\x1b[48:5:23m`
24	DeepSkyBlue4	`#005f87`	`\x1b[38:5:24m`	`\x1b[48:5:24m`
25	DeepSkyBlue4	`#005faf`	`\x1b[38:5:25m`	`\x1b[48:5:25m`
26	DodgerBlue3	`#005fd7`	`\x1b[38:5:26m`	`\x1b[48:5:26m`
27	DodgerBlue2	`#005fff`	`\x1b[38:5:27m`	`\x1b[48:5:27m`
28	Green4	`#008700`	`\x1b[38:5:28m`	`\x1b[48:5:28m`
29	SpringGreen4	`#00875f`	`\x1b[38:5:29m`	`\x1b[48:5:29m`
30	Turquoise4	`#008787`	`\x1b[38:5:30m`	`\x1b[48:5:30m`
31	DeepSkyBlue3	`#0087af`	`\x1b[38:5:31m`	`\x1b[48:5:31m`
32	DeepSkyBlue3	`#0087d7`	`\x1b[38:5:32m`	`\x1b[48:5:32m`
33	DodgerBlue1	`#0087ff`	`\x1b[38:5:33m`	`\x1b[48:5:33m`
34	Green3	`#00af00`	`\x1b[38:5:34m`	`\x1b[48:5:34m`
35	SpringGreen3	`#00af5f`	`\x1b[38:5:35m`	`\x1b[48:5:35m`
36	DarkCyan	`#00af87`	`\x1b[38:5:36m`	`\x1b[48:5:36m`
37	LightSeaGreen	`#00afaf`	`\x1b[38:5:37m`	`\x1b[48:5:37m`
38	DeepSkyBlue2	`#00afd7`	`\x1b[38:5:38m`	`\x1b[48:5:38m`
39	DeepSkyBlue1	`#00afff`	`\x1b[38:5:39m`	`\x1b[48:5:39m`
40	Green3	`#00d700`	`\x1b[38:5:40m`	`\x1b[48:5:40m`
41	SpringGreen3	`#00d75f`	`\x1b[38:5:41m`	`\x1b[48:5:41m`
42	SpringGreen2	`#00d787`	`\x1b[38:5:42m`	`\x1b[48:5:42m`
43	Cyan3	`#00d7af`	`\x1b[38:5:43m`	`\x1b[48:5:43m`
44	DarkTurquoise	`#00d7d7`	`\x1b[38:5:44m`	`\x1b[48:5:44m`
45	Turquoise2	`#00d7ff`	`\x1b[38:5:45m`	`\x1b[48:5:45m`
46	Green1	`#00ff00`	`\x1b[38:5:46m`	`\x1b[48:5:46m`
47	SpringGreen2	`#00ff5f`	`\x1b[38:5:47m`	`\x1b[48:5:47m`
48	SpringGreen1	`#00ff87`	`\x1b[38:5:48m`	`\x1b[48:5:48m`
49	MediumSpringGreen	`#00ffaf`	`\x1b[38:5:49m`	`\x1b[48:5:49m`
50	Cyan2	`#00ffd7`	`\x1b[38:5:50m`	`\x1b[48:5:50m`
51	Cyan1	`#00ffff`	`\x1b[38:5:51m`	`\x1b[48:5:51m`
52	DarkRed	`#5f0000`	`\x1b[38:5:52m`	`\x1b[48:5:52m`
53	DeepPink4	`#5f005f`	`\x1b[38:5:53m`	`\x1b[48:5:53m`
54	Purple4	`#5f0087`	`\x1b[38:5:54m`	`\x1b[48:5:54m`
55	Purple4	`#5f00af`	`\x1b[38:5:55m`	`\x1b[48:5:55m`
56	Purple3	`#5f00d7`	`\x1b[38:5:56m`	`\x1b[48:5:56m`
57	BlueViolet	`#5f00ff`	`\x1b[38:5:57m`	`\x1b[48:5:57m`
58	Orange4	`#5f5f00`	`\x1b[38:5:58m`	`\x1b[48:5:58m`
59	Grey37	`#5f5f5f`	`\x1b[38:5:59m`	`\x1b[48:5:59m`
60	MediumPurple4	`#5f5f87`	`\x1b[38:5:60m`	`\x1b[48:5:60m`
61	SlateBlue3	`#5f5faf`	`\x1b[38:5:61m`	`\x1b[48:5:61m`
62	SlateBlue3	`#5f5fd7`	`\x1b[38:5:62m`	`\x1b[48:5:62m`
63	RoyalBlue1	`#5f5fff`	`\x1b[38:5:63m`	`\x1b[48:5:63m`
64	Chartreuse4	`#5f8700`	`\x1b[38:5:64m`	`\x1b[48:5:64m`
65	DarkSeaGreen4	`#5f875f`	`\x1b[38:5:65m`	`\x1b[48:5:65m`
66	PaleTurquoise4	`#5f8787`	`\x1b[38:5:66m`	`\x1b[48:5:66m`
67	SteelBlue	`#5f87af`	`\x1b[38:5:67m`	`\x1b[48:5:67m`
68	SteelBlue3	`#5f87d7`	`\x1b[38:5:68m`	`\x1b[48:5:68m`
69	CornflowerBlue	`#5f87ff`	`\x1b[38:5:69m`	`\x1b[48:5:69m`
70	Chartreuse3	`#5faf00`	`\x1b[38:5:70m`	`\x1b[48:5:70m`
71	DarkSeaGreen4	`#5faf5f`	`\x1b[38:5:71m`	`\x1b[48:5:71m`
72	CadetBlue	`#5faf87`	`\x1b[38:5:72m`	`\x1b[48:5:72m`
73	CadetBlue	`#5fafaf`	`\x1b[38:5:73m`	`\x1b[48:5:73m`
74	SkyBlue3	`#5fafd7`	`\x1b[38:5:74m`	`\x1b[48:5:74m`
75	SteelBlue1	`#5fafff`	`\x1b[38:5:75m`	`\x1b[48:5:75m`
76	Chartreuse3	`#5fd700`	`\x1b[38:5:76m`	`\x1b[48:5:76m`
77	PaleGreen3	`#5fd75f`	`\x1b[38:5:77m`	`\x1b[48:5:77m`
78	SeaGreen3	`#5fd787`	`\x1b[38:5:78m`	`\x1b[48:5:78m`
79	Aquamarine3	`#5fd7af`	`\x1b[38:5:79m`	`\x1b[48:5:79m`
80	MediumTurquoise	`#5fd7d7`	`\x1b[38:5:80m`	`\x1b[48:5:80m`
81	SteelBlue1	`#5fd7ff`	`\x1b[38:5:81m`	`\x1b[48:5:81m`
82	Chartreuse2	`#5fff00`	`\x1b[38:5:82m`	`\x1b[48:5:82m`
83	SeaGreen2	`#5fff5f`	`\x1b[38:5:83m`	`\x1b[48:5:83m`
84	SeaGreen1	`#5fff87`	`\x1b[38:5:84m`	`\x1b[48:5:84m`
85	SeaGreen1	`#5fffaf`	`\x1b[38:5:85m`	`\x1b[48:5:85m`
86	Aquamarine1	`#5fffd7`	`\x1b[38:5:86m`	`\x1b[48:5:86m`
87	DarkSlateGray2	`#5fffff`	`\x1b[38:5:87m`	`\x1b[48:5:87m`
88	DarkRed	`#870000`	`\x1b[38:5:88m`	`\x1b[48:5:88m`
89	DeepPink4	`#87005f`	`\x1b[38:5:89m`	`\x1b[48:5:89m`
90	DarkMagenta	`#870087`	`\x1b[38:5:90m`	`\x1b[48:5:90m`
91	DarkMagenta	`#8700af`	`\x1b[38:5:91m`	`\x1b[48:5:91m`
92	DarkViolet	`#8700d7`	`\x1b[38:5:92m`	`\x1b[48:5:92m`
93	Purple	`#8700ff`	`\x1b[38:5:93m`	`\x1b[48:5:93m`
94	Orange4	`#875f00`	`\x1b[38:5:94m`	`\x1b[48:5:94m`
95	LightPink4	`#875f5f`	`\x1b[38:5:95m`	`\x1b[48:5:95m`
96	Plum4	`#875f87`	`\x1b[38:5:96m`	`\x1b[48:5:96m`
97	MediumPurple3	`#875faf`	`\x1b[38:5:97m`	`\x1b[48:5:97m`
98	MediumPurple3	`#875fd7`	`\x1b[38:5:98m`	`\x1b[48:5:98m`
99	SlateBlue1	`#875fff`	`\x1b[38:5:99m`	`\x1b[48:5:99m`
100	Yellow4	`#878700`	`\x1b[38:5:100m`	`\x1b[48:5:100m`
101	Wheat4	`#87875f`	`\x1b[38:5:101m`	`\x1b[48:5:101m`
102	Grey53	`#878787`	`\x1b[38:5:102m`	`\x1b[48:5:102m`
103	LightSlateGrey	`#8787af`	`\x1b[38:5:103m`	`\x1b[48:5:103m`
104	MediumPurple	`#8787d7`	`\x1b[38:5:104m`	`\x1b[48:5:104m`
105	LightSlateBlue	`#8787ff`	`\x1b[38:5:105m`	`\x1b[48:5:105m`
106	Yellow4	`#87af00`	`\x1b[38:5:106m`	`\x1b[48:5:106m`
107	DarkOliveGreen3	`#87af5f`	`\x1b[38:5:107m`	`\x1b[48:5:107m`
108	DarkSeaGreen	`#87af87`	`\x1b[38:5:108m`	`\x1b[48:5:108m`
109	LightSkyBlue3	`#87afaf`	`\x1b[38:5:109m`	`\x1b[48:5:109m`
110	LightSkyBlue3	`#87afd7`	`\x1b[38:5:110m`	`\x1b[48:5:110m`
111	SkyBlue2	`#87afff`	`\x1b[38:5:111m`	`\x1b[48:5:111m`
112	Chartreuse2	`#87d700`	`\x1b[38:5:112m`	`\x1b[48:5:112m`
113	DarkOliveGreen3	`#87d75f`	`\x1b[38:5:113m`	`\x1b[48:5:113m`
114	PaleGreen3	`#87d787`	`\x1b[38:5:114m`	`\x1b[48:5:114m`
115	DarkSeaGreen3	`#87d7af`	`\x1b[38:5:115m`	`\x1b[48:5:115m`
116	DarkSlateGray3	`#87d7d7`	`\x1b[38:5:116m`	`\x1b[48:5:116m`
117	SkyBlue1	`#87d7ff`	`\x1b[38:5:117m`	`\x1b[48:5:117m`
118	Chartreuse1	`#87ff00`	`\x1b[38:5:118m`	`\x1b[48:5:118m`
119	LightGreen	`#87ff5f`	`\x1b[38:5:119m`	`\x1b[48:5:119m`
120	LightGreen	`#87ff87`	`\x1b[38:5:120m`	`\x1b[48:5:120m`
121	PaleGreen1	`#87ffaf`	`\x1b[38:5:121m`	`\x1b[48:5:121m`
122	Aquamarine1	`#87ffd7`	`\x1b[38:5:122m`	`\x1b[48:5:122m`
123	DarkSlateGray1	`#87ffff`	`\x1b[38:5:123m`	`\x1b[48:5:123m`
124	Red3	`#af0000`	`\x1b[38:5:124m`	`\x1b[48:5:124m`
125	DeepPink4	`#af005f`	`\x1b[38:5:125m`	`\x1b[48:5:125m`
126	MediumVioletRed	`#af0087`	`\x1b[38:5:126m`	`\x1b[48:5:126m`
127	Magenta3	`#af00af`	`\x1b[38:5:127m`	`\x1b[48:5:127m`
128	DarkViolet	`#af00d7`	`\x1b[38:5:128m`	`\x1b[48:5:128m`
129	Purple	`#af00ff`	`\x1b[38:5:129m`	`\x1b[48:5:129m`
130	DarkOrange3	`#af5f00`	`\x1b[38:5:130m`	`\x1b[48:5:130m`
131	IndianRed	`#af5f5f`	`\x1b[38:5:131m`	`\x1b[48:5:131m`
132	HotPink3	`#af5f87`	`\x1b[38:5:132m`	`\x1b[48:5:132m`
133	MediumOrchid3	`#af5faf`	`\x1b[38:5:133m`	`\x1b[48:5:133m`
134	MediumOrchid	`#af5fd7`	`\x1b[38:5:134m`	`\x1b[48:5:134m`
135	MediumPurple2	`#af5fff`	`\x1b[38:5:135m`	`\x1b[48:5:135m`
136	DarkGoldenrod	`#af8700`	`\x1b[38:5:136m`	`\x1b[48:5:136m`
137	LightSalmon3	`#af875f`	`\x1b[38:5:137m`	`\x1b[48:5:137m`
138	RosyBrown	`#af8787`	`\x1b[38:5:138m`	`\x1b[48:5:138m`
139	Grey63	`#af87af`	`\x1b[38:5:139m`	`\x1b[48:5:139m`
140	MediumPurple2	`#af87d7`	`\x1b[38:5:140m`	`\x1b[48:5:140m`
141	MediumPurple1	`#af87ff`	`\x1b[38:5:141m`	`\x1b[48:5:141m`
142	Gold3	`#afaf00`	`\x1b[38:5:142m`	`\x1b[48:5:142m`
143	DarkKhaki	`#afaf5f`	`\x1b[38:5:143m`	`\x1b[48:5:143m`
144	NavajoWhite3	`#afaf87`	`\x1b[38:5:144m`	`\x1b[48:5:144m`
145	Grey69	`#afafaf`	`\x1b[38:5:145m`	`\x1b[48:5:145m`
146	LightSteelBlue3	`#afafd7`	`\x1b[38:5:146m`	`\x1b[48:5:146m`
147	LightSteelBlue	`#afafff`	`\x1b[38:5:147m`	`\x1b[48:5:147m`
148	Yellow3	`#afd700`	`\x1b[38:5:148m`	`\x1b[48:5:148m`
149	DarkOliveGreen3	`#afd75f`	`\x1b[38:5:149m`	`\x1b[48:5:149m`
150	DarkSeaGreen3	`#afd787`	`\x1b[38:5:150m`	`\x1b[48:5:150m`
151	DarkSeaGreen2	`#afd7af`	`\x1b[38:5:151m`	`\x1b[48:5:151m`
152	LightCyan3	`#afd7d7`	`\x1b[38:5:152m`	`\x1b[48:5:152m`
153	LightSkyBlue1	`#afd7ff`	`\x1b[38:5:153m`	`\x1b[48:5:153m`
154	GreenYellow	`#afff00`	`\x1b[38:5:154m`	`\x1b[48:5:154m`
155	DarkOliveGreen2	`#afff5f`	`\x1b[38:5:155m`	`\x1b[48:5:155m`
156	PaleGreen1	`#afff87`	`\x1b[38:5:156m`	`\x1b[48:5:156m`
157	DarkSeaGreen2	`#afffaf`	`\x1b[38:5:157m`	`\x1b[48:5:157m`
158	DarkSeaGreen1	`#afffd7`	`\x1b[38:5:158m`	`\x1b[48:5:158m`
159	PaleTurquoise1	`#afffff`	`\x1b[38:5:159m`	`\x1b[48:5:159m`
160	Red3	`#d70000`	`\x1b[38:5:160m`	`\x1b[48:5:160m`
161	DeepPink3	`#d7005f`	`\x1b[38:5:161m`	`\x1b[48:5:161m`
162	DeepPink3	`#d70087`	`\x1b[38:5:162m`	`\x1b[48:5:162m`
163	Magenta3	`#d700af`	`\x1b[38:5:163m`	`\x1b[48:5:163m`
164	Magenta3	`#d700d7`	`\x1b[38:5:164m`	`\x1b[48:5:164m`
165	Magenta2	`#d700ff`	`\x1b[38:5:165m`	`\x1b[48:5:165m`
166	DarkOrange3	`#d75f00`	`\x1b[38:5:166m`	`\x1b[48:5:166m`
167	IndianRed	`#d75f5f`	`\x1b[38:5:167m`	`\x1b[48:5:167m`
168	HotPink3	`#d75f87`	`\x1b[38:5:168m`	`\x1b[48:5:168m`
169	HotPink2	`#d75faf`	`\x1b[38:5:169m`	`\x1b[48:5:169m`
170	Orchid	`#d75fd7`	`\x1b[38:5:170m`	`\x1b[48:5:170m`
171	MediumOrchid1	`#d75fff`	`\x1b[38:5:171m`	`\x1b[48:5:171m`
172	Orange3	`#d78700`	`\x1b[38:5:172m`	`\x1b[48:5:172m`
173	LightSalmon3	`#d7875f`	`\x1b[38:5:173m`	`\x1b[48:5:173m`
174	LightPink3	`#d78787`	`\x1b[38:5:174m`	`\x1b[48:5:174m`
175	Pink3	`#d787af`	`\x1b[38:5:175m`	`\x1b[48:5:175m`
176	Plum3	`#d787d7`	`\x1b[38:5:176m`	`\x1b[48:5:176m`
177	Violet	`#d787ff`	`\x1b[38:5:177m`	`\x1b[48:5:177m`
178	Gold3	`#d7af00`	`\x1b[38:5:178m`	`\x1b[48:5:178m`
179	LightGoldenrod3	`#d7af5f`	`\x1b[38:5:179m`	`\x1b[48:5:179m`
180	Tan	`#d7af87`	`\x1b[38:5:180m`	`\x1b[48:5:180m`
181	MistyRose3	`#d7afaf`	`\x1b[38:5:181m`	`\x1b[48:5:181m`
182	Thistle3	`#d7afd7`	`\x1b[38:5:182m`	`\x1b[48:5:182m`
183	Plum2	`#d7afff`	`\x1b[38:5:183m`	`\x1b[48:5:183m`
184	Yellow3	`#d7d700`	`\x1b[38:5:184m`	`\x1b[48:5:184m`
185	Khaki3	`#d7d75f`	`\x1b[38:5:185m`	`\x1b[48:5:185m`
186	LightGoldenrod2	`#d7d787`	`\x1b[38:5:186m`	`\x1b[48:5:186m`
187	LightYellow3	`#d7d7af`	`\x1b[38:5:187m`	`\x1b[48:5:187m`
188	Grey84	`#d7d7d7`	`\x1b[38:5:188m`	`\x1b[48:5:188m`
189	LightSteelBlue1	`#d7d7ff`	`\x1b[38:5:189m`	`\x1b[48:5:189m`
190	Yellow2	`#d7ff00`	`\x1b[38:5:190m`	`\x1b[48:5:190m`
191	DarkOliveGreen1	`#d7ff5f`	`\x1b[38:5:191m`	`\x1b[48:5:191m`
192	DarkOliveGreen1	`#d7ff87`	`\x1b[38:5:192m`	`\x1b[48:5:192m`
193	DarkSeaGreen1	`#d7ffaf`	`\x1b[38:5:193m`	`\x1b[48:5:193m`
194	Honeydew2	`#d7ffd7`	`\x1b[38:5:194m`	`\x1b[48:5:194m`
195	LightCyan1	`#d7ffff`	`\x1b[38:5:195m`	`\x1b[48:5:195m`
196	Red1	`#ff0000`	`\x1b[38:5:196m`	`\x1b[48:5:196m`
197	DeepPink2	`#ff005f`	`\x1b[38:5:197m`	`\x1b[48:5:197m`
198	DeepPink1	`#ff0087`	`\x1b[38:5:198m`	`\x1b[48:5:198m`
199	DeepPink1	`#ff00af`	`\x1b[38:5:199m`	`\x1b[48:5:199m`
200	Magenta2	`#ff00d7`	`\x1b[38:5:200m`	`\x1b[48:5:200m`
201	Magenta1	`#ff00ff`	`\x1b[38:5:201m`	`\x1b[48:5:201m`
202	OrangeRed1	`#ff5f00`	`\x1b[38:5:202m`	`\x1b[48:5:202m`
203	IndianRed1	`#ff5f5f`	`\x1b[38:5:203m`	`\x1b[48:5:203m`
204	IndianRed1	`#ff5f87`	`\x1b[38:5:204m`	`\x1b[48:5:204m`
205	HotPink	`#ff5faf`	`\x1b[38:5:205m`	`\x1b[48:5:205m`
206	HotPink	`#ff5fd7`	`\x1b[38:5:206m`	`\x1b[48:5:206m`
207	MediumOrchid1	`#ff5fff`	`\x1b[38:5:207m`	`\x1b[48:5:207m`
208	DarkOrange	`#ff8700`	`\x1b[38:5:208m`	`\x1b[48:5:208m`
209	Salmon1	`#ff875f`	`\x1b[38:5:209m`	`\x1b[48:5:209m`
210	LightCoral	`#ff8787`	`\x1b[38:5:210m`	`\x1b[48:5:210m`
211	PaleVioletRed1	`#ff87af`	`\x1b[38:5:211m`	`\x1b[48:5:211m`
212	Orchid2	`#ff87d7`	`\x1b[38:5:212m`	`\x1b[48:5:212m`
213	Orchid1	`#ff87ff`	`\x1b[38:5:213m`	`\x1b[48:5:213m`
214	Orange1	`#ffaf00`	`\x1b[38:5:214m`	`\x1b[48:5:214m`
215	SandyBrown	`#ffaf5f`	`\x1b[38:5:215m`	`\x1b[48:5:215m`
216	LightSalmon1	`#ffaf87`	`\x1b[38:5:216m`	`\x1b[48:5:216m`
217	LightPink1	`#ffafaf`	`\x1b[38:5:217m`	`\x1b[48:5:217m`
218	Pink1	`#ffafd7`	`\x1b[38:5:218m`	`\x1b[48:5:218m`
219	Plum1	`#ffafff`	`\x1b[38:5:219m`	`\x1b[48:5:219m`
220	Gold1	`#ffd700`	`\x1b[38:5:220m`	`\x1b[48:5:220m`
221	LightGoldenrod2	`#ffd75f`	`\x1b[38:5:221m`	`\x1b[48:5:221m`
222	LightGoldenrod2	`#ffd787`	`\x1b[38:5:222m`	`\x1b[48:5:222m`
223	NavajoWhite1	`#ffd7af`	`\x1b[38:5:223m`	`\x1b[48:5:223m`
224	MistyRose1	`#ffd7d7`	`\x1b[38:5:224m`	`\x1b[48:5:224m`
225	Thistle1	`#ffd7ff`	`\x1b[38:5:225m`	`\x1b[48:5:225m`
226	Yellow1	`#ffff00`	`\x1b[38:5:226m`	`\x1b[48:5:226m`
227	LightGoldenrod1	`#ffff5f`	`\x1b[38:5:227m`	`\x1b[48:5:227m`
228	Khaki1	`#ffff87`	`\x1b[38:5:228m`	`\x1b[48:5:228m`
229	Wheat1	`#ffffaf`	`\x1b[38:5:229m`	`\x1b[48:5:229m`
230	Cornsilk1	`#ffffd7`	`\x1b[38:5:230m`	`\x1b[48:5:230m`
231	Grey100	`#ffffff`	`\x1b[38:5:231m`	`\x1b[48:5:231m`
232	Grey3	`#080808`	`\x1b[38:5:232m`	`\x1b[48:5:232m`
233	Grey7	`#121212`	`\x1b[38:5:233m`	`\x1b[48:5:233m`
234	Grey11	`#1c1c1c`	`\x1b[38:5:234m`	`\x1b[48:5:234m`
235	Grey15	`#262626`	`\x1b[38:5:235m`	`\x1b[48:5:235m`
236	Grey19	`#303030`	`\x1b[38:5:236m`	`\x1b[48:5:236m`
237	Grey23	`#3a3a3a`	`\x1b[38:5:237m`	`\x1b[48:5:237m`
238	Grey27	`#444444`	`\x1b[38:5:238m`	`\x1b[48:5:238m`
239	Grey30	`#4e4e4e`	`\x1b[38:5:239m`	`\x1b[48:5:239m`
240	Grey35	`#585858`	`\x1b[38:5:240m`	`\x1b[48:5:240m`
241	Grey39	`#626262`	`\x1b[38:5:241m`	`\x1b[48:5:241m`
242	Grey42	`#6c6c6c`	`\x1b[38:5:242m`	`\x1b[48:5:242m`
243	Grey46	`#767676`	`\x1b[38:5:243m`	`\x1b[48:5:243m`
244	Grey50	`#808080`	`\x1b[38:5:244m`	`\x1b[48:5:244m`
245	Grey54	`#8a8a8a`	`\x1b[38:5:245m`	`\x1b[48:5:245m`
246	Grey58	`#949494`	`\x1b[38:5:246m`	`\x1b[48:5:246m`
247	Grey62	`#9e9e9e`	`\x1b[38:5:247m`	`\x1b[48:5:247m`
248	Grey66	`#a8a8a8`	`\x1b[38:5:248m`	`\x1b[48:5:248m`
249	Grey70	`#b2b2b2`	`\x1b[38:5:249m`	`\x1b[48:5:249m`
250	Grey74	`#bcbcbc`	`\x1b[38:5:250m`	`\x1b[48:5:250m`
251	Grey78	`#c6c6c6`	`\x1b[38:5:251m`	`\x1b[48:5:251m`
252	Grey82	`#d0d0d0`	`\x1b[38:5:252m`	`\x1b[48:5:252m`
253	Grey85	`#dadada`	`\x1b[38:5:253m`	`\x1b[48:5:253m`
254	Grey89	`#e4e4e4`	`\x1b[38:5:254m`	`\x1b[48:5:254m`
255	Grey93	`#eeeeee`	`\x1b[38:5:255m`	`\x1b[48:5:255m`

True Color

	Escape Code	Example
foreground color	`\x1b[38;2;${red};${green};${blue}m`	`\x1b[38;2;255;0;0m`
background color	`\x1b[48;2;${red};${green};${blue}m`	`\x1b[48;2;255;0;0m`

Cheatsheets: Tmux Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Commands

Session

# Start a new tmux session.
tmux

# Start a new tmux session with name.
tmux new -s <session-name>

# List all sessions.
tmux ls

# Attach to the last session.
tmux attach

# Attach to a session with name.
tmux attach -t <session-name>

# Kill a session.
tmux kill-session -t <session-name>

# Kill sessions other than the current one.
tmux kill-session -a

# Kill sessions other than the named one.
tmux kill-session -a -t <session-name>

Window

# Create a new window and switch to it.
tmux new-window

# Create a a new window with name, but do not swith to it.
tmux new-window -t -n <window-name>

# Kill the current window.
tmux kill-window

# Kill the target window.
tmux kill-window -t <window-name>

# Send keys to the target window. (End with C-j for enter)
tmux send-keys -t <window-name> <command> C-j

Info

# Show tmux session information.
tmux info

Config

# Reload config.
tmux source-file ~/.tmux.conf

# Show config.
tmux show-options -g

HotKeys

Session Management


`C-b d`	Dettach from session
`C-b s`	Show all sessions
`C-b $`	Rename sessions
`C-b (`	Go to the previous session
`C-b )`	Go to the next session

Window Management


`C-b c`	Create a new window
`C-b p`	Go to the previous window
`C-b n`	Go to the next window
`C-b ,`	Rename window
`C-b &`	Close window
`C-b w`	List window
`C-b f`	Find window
`C-b l`	Last window
`C-b .`	Move window
`C-b 0...9`	Goto # window

Pane Management


`C-b "`	Split horizontally
`C-b %`	Split vertically
`C-b !`	Convert pane to window
`C-b x`	Kill pane
`C-b <arrow>`	Switch panes
`C-b C-<arrow>`	Adjust pane size
`C-b <space>`	Toggle pane layout
`C-b {/}`	Move to Left/Right
`C-b o`	Goto next panes
`C-b z`	toggle full-screen
`C-b ;`	Toggle Last pane
`C-b q`	Show numbers
`C-b q 0...9`	Goto # pane

DevMemo – cheatsheet

Cheatsheets: Cheatsheets

Cheatsheets: Ansible Cheatsheet

Install

Inventory

Host.ini

Host Variables

Ansible Playbook

Hello World

Privilege Escalation

Commonly Used Modules

Package

Service

File Basics

File Copy

LineInFile

Commands

Git

User

Debug

All Modules

Commands

Run Command For A Single Module

Run Command For A Playbook

Cheatsheets: ASCII Code Cheatsheet

ASCII Code Table

Cheatsheets: Docker Cheatsheet

Installation

Install Docker On Ubuntu

Install Docker On Debian

Run Docker Commands Without Sudo

Commands

Image Management

Container Management

File Copy

Network Management

Docker In Docker

Dockerfile Builder Commands

Docker Config

Insecure Docker Registry

Cheatsheets: Docker Compose Cheatsheet

Commands

Basics

Check Status

Images

File Operations

Others

Docker Compose Config

An Basic Example

Spec

Build

Network

Environment Variable

Commands

Labels

Logging

Dependencies

Cheatsheets: Git Cheatsheet

Commands

New Repo

Config

Branch

Changes

Tags

Remote

Submodule

Aliases

Cheatsheets: Kubernetes Cheatsheet

Kubectl Commands

Annotate

Api Version

Apply

Attach

Autoscale

Cluster Info

Config

View Config

Context

Cluster

Credentials