azure-rest-adventure
go on a RESTful adventure to create a service on azure
What
A learning adventure that teaches how to write restful services and how to deploy those services to azure.
Goals
The goal of this adventure is to teach you how to build a RESTful service that runs on azure
and works like a key-value store. That is, it supports storing data that matches the following
format:
{
name: "unique name",
value: "any value"
}
It will support creating new items, listing items, querying specific items, and removing items.
Getting started
- First, make sure you have node installed.
- Then
npm install -g azure-rest-adventure
- Then
azure-rest-adventure
or azradv
for short
Main screen
This is what you see when you run azradv
The list shows all the different segments of the lesson,
listed in the order they should be completed. Selecting
an entry (by hitting enter with it highlighted) outputs
a description of the problem you'll need to solve for
that portion of the lesson, as well as a description
of how to verify that you've successfully completed it.
After a lesson is completed, run azradv
again to select
the next lesson.
Lessons
Setup
The setup lesson is where we configure our nodejs project.
You'll be asked to setup a directory for the project,
configure the project (by creating a package.json file)
and install dependencies.
To verify completion, we'll ask you to pass the directory
name (yes, you can pass .
as the path) that your project
lives in, so we can check for the following things:
- package.json file exists
- package.json#main entry exists
- the file referenced by package.json#main exists
- package.json#dependencies contains express
- node_modules\express directory exists
Scaffolded
The scaffolded lesson is where we define our core logic
for the project. You'll be asked to create an entrypoint
(this is the file referenced in the above step in package.json#main
)
that creates an express app and starts listening on port 3000
.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
Todo: we should also validate that the application is actually listening
Postone
The postone lesson is where we define our first RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items
that's capable of receiving the following in the request body:
{
name: "some string",
value: "some string"
}
And responds with a 200
on success, a 400
when the request is malformed,
and a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP POST /items
with a valid body
Postmany
The postmany lesson is where we define a new RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items
that's capable of receiving the following in the request body:
Where ...
indicates 0-N additional objects that match that format.
[{
name: "some string",
value: "some string"
}, ...]
And responds with a 200
on success, a 400
when the request is malformed,
and a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP POST /items
with a valid body
Getone
The getone lesson is where we define a new RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items/:name
that's capable of responding with a given
item if that item exists.
It responds with a 200
and the following body on success:
{
name: "the passed name value",
value: "some value"
}
a 400
when the request is malformed,
a 404
when no such item is found,
and finally a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP GET /items/item-name
and returns a valid response body - your project supports
HTTP GET /items/no-such-item
and returns a 404
status code
Getmany
The getmany lesson is where we define a new RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items
that's capable of responding with a given
item if that item exists.
It responds with a 200
and the following body on success:
Where ...
indicates 0-N additional objects that match that format.
[{
name: "the passed name value",
value: "some value"
}, ...]
a 400
when the request is malformed,
and finally a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP GET /items
and returns a valid response body - your project supports
HTTP POST /items
to create an item,
followed by HTTP GET /items
to enumerate all items, including the newly created one.
Deleteone
The deleteone lesson is where we define a new RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items/:name
that's capable of removing that item if it exists.
It responds with a 200
on success,
a 400
when the request is malformed,
a 404
when no such item is found,
and finally a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP DELETE /items/item-name
and returns a valid response body - your project supports
HTTP POST /items
to create an item,
followed by HTTP DELETE /items/item-name
to create and then delete an item.
Deletemany
The deletemany lesson is where we define a new RESTful endpoint
for the project. You'll be asked to create an endpoint at
/items
that's capable of removing all items.
It responds with a 200
when items are removed,
a 400
when the request is malformed,
a 404
when no items exists,
and finally a 500
when an internal error occurs.
To verify completion, we'll ask you to pass the entrypoint
file path so we can start your application and check for
the following things:
- your entrypoint loads without issue
- your entrypoint outputs "listening on ... 3000" where "..." may be anything
- your project supports
HTTP DELETE /items
and returns a valid response - your project supports
HTTP POST /items
to create a few items,
followed by HTTP DELETE /items
to create and then delete items.
Azure
The azure lesson is where we deploy the service to azure and validate
it's functioning there. You'll be asked to deploy to azure.
To verify completion, we'll ask you to pass the url to your azure service
(including protocol, like http://
) and test the following requests:
- HTTP DELETE /items
- HTTP POST /items
<one item>
- HTTP POST /items
<many items>
- HTTP GET /items
- HTTP GET /items/specific-item
- HTTP DELETE /items/specific-item
- HTTP DELETE /items
License
MIT