Chapters: 
O365 Plumbing
allison@frodo:~/projects/azure/Camelot$ cd ~/projects/azure/Camelot
python3 -m venv .venv
source .venv/bin/activate
python --version
Python 3.12.10
((.venv) ) allison@frodo:~/projects/azure/Camelot$

 

Our first working mission:

Arthur submits a valid Quest containing an artist and one or more album names. Lancelot conducts the research in Azure and returns proposed covers, sources, and any side loot discovered.

For example: 

{
  "artist": "10cc",
  "albums": [
    "The Very Best of 10cc",
    "Bloody Tourists"
  ]
}

Arthur remains the keeper of Music Trove and decides what is accepted. Lancelot is the cloud-based quest leader: temporary residence, advanced communications, no authority to alter Arthur’s catalogue directly.

You are seeing two connected realms, not two competing kinds of Azure DevOps account. 

flowchart LR
    F["Frodo<br/>Gmail sign-in"] --> D["Azure DevOps<br/>Plan and coordinate"]
    D --> A["Microsoft Azure<br/>Run Lancelot"]
    A --> D

Door

Address

What belongs there

Azure DevOps

dev.azure.com

Quest work items, Git repository, Wiki, pipelines, history

Microsoft Azure portal

portal.azure.com

Subscription, billing, Python container, storage, managed identity, secrets

Your same Gmail-backed Microsoft identity can enter both.

What we need

We need both, in this order:

  1. An Azure DevOps organization and project for The 29 Days of Azure.
  2. An Azure subscription to host Lancelot.
  3. Later, a pipeline connects the DevOps project to Lancelot’s Azure resources.

The hierarchy is: 

Frodo’s Microsoft sign-in
├── Azure subscription
│   └── Resource group
│       └── Lancelot container and supporting resources
│
└── Azure DevOps organization
    └── Project: 29 Days of Azure
        ├── Boards — Arthur’s Quests
        ├── Repos — Lancelot’s Python code
        ├── Pipelines — build and deploy
        └── Wiki — discoveries and documentation

First, find out what already exists

Door 1: Azure DevOps

Go to dev.azure.com and use the Gmail identity.

You should see either:

  • an existing organization, which you can open; or
  • Create new organization.

Once inside the organization, look for an existing project or select New project. The project could be named:

29 Days of Azure

That is where we begin. We don’t need to create Lancelot yet.

Door 2: Azure

In another tab, go to portal.azure.com, then search for:

Subscriptions

Your one-month test subscription should appear with a status such as Active or Enabled. This is Lancelot’s future lodging and the source of any charges.

Microsoft currently requires an active Azure subscription when creating a new Azure DevOps organization. Trial subscriptions are listed as generally supported, although particular trial offers can sometimes be rejected for DevOps billing. Microsoft’s organization instructions and billing FAQ explain the current arrangement.

The immediate destination

For today, enter:

dev.azure.com → your organization → 29 Days of Azure

That is the workshop. The Azure portal is where we provision Lancelot after the Quest interface has a shape.

https://dev.azure.com/eckford/Camelot

 

The 29 Days of Azure — current position

We are building Lancelot, Arthur’s trustworthy cloud scout, as a contained Azure experiment.

The cast

  • Arthur — Music Trove authority, high on the Welsh dresser. Selects the work and reviews the results.
  • Lancelot — not built yet. Will live temporarily in Azure and conduct bounded research Quests.
  • Frodo — local development machine and present bridge into Azure. Complaints remain operationally normal.
  • Camelot — both the wider realm and the Azure DevOps project where Lancelot’s code and work will be managed.

The Quest

A valid Quest requires exactly two categories of input: 

{
  "artist": "10cc",
  "albums": [
    "The Very Best of 10cc",
    "Bloody Tourists"
  ]
}

The number of albums determines the quantity of required results.

Lancelot returns:

  • one suitable cover proposal for each album;
  • the source for each cover;
  • useful side loot discovered during the Quest, initially including band-member information;
  • Bonus Rewards $$$ for valuable discoveries beyond the primary goal.

Arthur’s album model remains intentionally simple:

The album contains these songs and needs a suitable cover.

We are not requiring edition matching, catalogue numbers, formats, release versions, or other sticky Discogs details. Arthur reviews proposals; Lancelot does not silently alter Music Trove.

Azure mental map

These are two connected places:

Place

Purpose

Azure DevOps

Repository, Boards, Quest history, future pipeline and documentation

Microsoft Azure

Eventually runs Lancelot’s Python service and holds its cloud resources

Current Azure DevOps structure: 

Organization: eckford
└── Project: Camelot
    ├── Boards
    └── Repo: Camelot

Existing Board items:

  • #1 — The reaches of Camelot spread out and beyond
  • #2 — create git workflow

We wisely stopped short of assigning a Quest: Lancelot must exist before Arthur can send him one.

What has been completed

The Camelot Azure repository was initialized with:

  • README.md
  • Python .gitignore
  • default branch main
  • initial commit e1f3083a

Frodo’s RSA public key was added to Azure DevOps through the direct SSH-key settings page.

SSH authentication was successfully verified: 

remote: Shell access is not supported.
shell request failed on channel 0

That is the expected result: Azure Repos accepts authenticated Git traffic but provides no general interactive shell.  ************* !!!!!

The repository was then cloned successfully to: 

/home/allison/projects/azure/Camelot

Its current state is clean: 

On branch main
Your branch is up to date with 'origin/main'.

Exact stopping point

Lancelot now has:

  • a working Azure DevOps project;
  • an initialized Git repository;
  • a clean local clone on Frodo;
  • authenticated SSH access between Frodo and Azure Repos.

Lancelot does not yet have:

  • Python application code;
  • a Quest interface;
  • tests;
  • a container;
  • Azure runtime resources;
  • access to Discogs or any other cover source;
  • an assigned Quest.

Next step

Inside /home/allison/projects/azure/Camelot, we build the smallest useful Lancelot: a Python service that accepts an artist plus one or more album names, validates the Quest, and returns a structured placeholder response.

No Azure deployment and no real 10cc research yet. First, Lancelot must learn how to receive a Quest.

Azure