Set up your machine once.

The labs build real resources in a real subscription. Signing up gives you three things: a $200 credit that lasts your first 30 days, 12 months of extra free quota on 20+ popular services (new customers only), and 65+ services that stay free forever. Most labs cost nothing or a few cents and tear down what they built. A handful do not: the AKS clusters, the full app deploy and the disaster-recovery labs bill by the hour while they run. What each lab costs lists them, and each lab's header says the same before you start.

→ Sign up: azure.microsoft.com/free — you end up with a subscription (the billing container everything lives in). It asks for a credit or debit card to verify your identity; Azure does not charge it unless you move to pay-as-you-go. After the 30 days a free account has to make that move before it can create paid resources, and from then on the card pays for whatever you leave running.

Every lab is written in Bash — the commands use Bash variables, loops, and <<EOF here-docs. Run them in a Bash shell so they work exactly as written:

macOS / Linux   your Terminal is already Bash-compatible — nothing to do.
Windows         install Git (it bundles "Git Bash"), then use Git Bash — not PowerShell:
                  winget install --exact --id Git.Git
              then open Git Bash from the Start menu and work there.

The winget installs below can run from PowerShell, but run the actual lab commands in Git Bash. No Git? WSL or Azure Cloud Shell (bottom of page) are Bash too.

why PowerShell cannot read Bash syntax — NAME="x", $RANDOM, and cat > file <<EOF all fail there. Git Bash, WSL, and Cloud Shell run every lab unchanged.

One Git Bash quirk, already handled: Git Bash rewrites any argument starting with / into a Windows path, which breaks Azure resource IDs (a --scope /subscriptions/… then fails with MissingSubscription). Two more Git Bash gaps: it has no zip (labs that zip an app show a PowerShell Compress-Archive line beside it) and no /proc (the one lab that reads a random ID from there shows a fallback). Every lab defuses the path problem with export MSYS_NO_PATHCONV=1 as its first line — leave that line in place and it just works. (On macOS/Linux that line does nothing, so it is safe everywhere.)

Every lab after this is a stack of Bash commands. Before Class 7 asks you to run one against Azure, run a few that cannot break anything. Use the Bash window from step 02 (or Cloud Shell set to Bash). Before each block, read the comment and guess what will appear. Then run it and compare.

echo "$0"                     # expect bash, -bash or /usr/bin/bash

If it says powershell or pwsh, you are in the wrong window. Go back to step 02.

NAME="Ada"                    # guess: what does this line print?
echo "Hello, $NAME"           # Hello, Ada

The first line prints nothing. Storing a value is quiet; only echo shows it. The labs do this all the time (RG="training-group"), and a blank line after it is success, not a hang. Now change Ada to your own name, guess the output, and run both lines again.

mkdir -p practice             # makes a folder; prints nothing when it works
echo $?                       # 0 means the last command succeeded
ls -d practice                # practice

Many Azure commands in the labs end with -o none, which does the same thing on purpose: no output unless something fails. The checkpoint line after it is how you see the result.

cat > practice/note.txt <<'EOF'
first line
second line
EOF
cat practice/note.txt         # first line, then second line

cat > practice/note.txt <<'EOF' means: put everything that follows into that file, until a line that says only EOF. Labs use this to write JSON, Bicep and Python files. If Bash shows a lone > and waits, it has not seen the closing EOF yet. Paste the rest of the block, or press Ctrl+C and paste the whole block again.

echo one \
  two                         # one two

A backslash at the very end of a line means the command carries on to the next. Long az commands are written this way so each option sits on its own line.

greet() {
  echo "Hello, $1"
}
greet Ada                     # Hello, Ada
greet Ben                     # guess first

The first three lines define greet and print nothing. $1 is the first word after the function's name. Labs C and D wrap each step in a function like this: one paste defines the step, the next line runs it, and if it fails you run that one line again instead of re-pasting twenty commands.

On your own: write a function called show_rg that prints Resource group: followed by its first argument, then call it with training-group.

show_rg() {
  echo "Resource group: $1"
}
show_rg training-group        # Resource group: training-group

rm -r practice                # clean up the practice folder

ready when you can say which shell you are in, store and print a value, write and read a file with a block, and explain why mkdir printed nothing. That is everything Classes 7 to 16 assume about the terminal. Class 25 comes back for loops, error handling and safe automation.

The az command every lab uses. One line for your OS.

winget install --exact --id Microsoft.AzureCLI

brew update && brew install azure-cli

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

verify az version -> prints 2.x. Not found? Reopen the terminal so az is on PATH. No winget? MSI at aka.ms/installazurecliwindows.

Opens a browser, then hands control back to the terminal. Set the subscription if you have more than one.

az login
az account show --query name -o tsv                    # which sub am I in?
az account set --subscription "<id-or-name>"            # switch if needed

verify az account show -> prints your subscription as JSON. Signed in.

Skip until a lab asks for it. The Bicep and CLI labs do not need it.

winget install --exact --id Hashicorp.Terraform

brew tap hashicorp/tap && brew install hashicorp/tap/terraform

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

verify terraform -version -> Terraform v1.x. Python (AI labs) is preinstalled on macOS/Linux; on Windows: winget install --exact --id Python.Python.3.12.

Before you clone anything: make one folder for all the labs, somewhere you will find again — your home directory or Documents. Note the path. Every lab clones or builds here, so you always know where your work is.

cd ~                          # home (Windows: cd $HOME) — or wherever you'll remember
mkdir azure-labs              # any name you'll recognise later
cd azure-labs
pwd                           # <- note this path. this is home base.

verify pwd prints your folder's full path. Remember it — you will cd back here at the start of every lab, then run its git clone.