Build a Stateless Microservice With GitHub Copilot in VSCode - Related to neon,, productivity, software, stateless, functions

Build a Stateless Microservice With GitHub Copilot in VSCode

Microsoft CEO Satya Nadella in the recent past revealed that GitHub Copilot is now free for all developers in VSCode. This is a game-changer in the software development industry. Github Copilot is an AI code assistant that helps developers finish their coding tasks easily and quickly. It also helps suggest code snippets and autocomplete functions.

In this article, we will learn how to use GitHub Copilot using VSCode in a step-by-step manner for creating the first stateless flask microservice. This is a beginner-friendly guide showcasing how Copilot helps reduce the development time and simplify the process.

As our primary focus will be on GitHub Copilot, I will write a high level on the software installation needed. If any installation issues are seen, it is expected that readers would have to solve them locally or comment in this article, where I can try to help.

1. Install Visual Studio Code on Mac or Windows from VSCode (In my examples, I used Mac).

2. Install GitHub Copilot extension in VSCode:

Open VSCode and navigate to the Extensions view on the left, as per the below screenshot.

If you do not have a GitHub account, please create one in GitHub.

4. Install Python in your system from Python based on Windows/Mac. Note that we are not installing Flask now; we will do it in a later step while installing the application to run.

1. In VSCode, on the right side with the Copilot pallet, under "Ask Copilot," type: Create a Flask app.

There are two ways we can ask Copilot. One is to create the Flask project folder with files and ask Copilot to add the code. Or, start from nothing and ask to create a Flask app.

2. We see that the project-created files will have [website], where a few default APIs are already generated. Now, we will create 2 APIs using Copilot. The first API is simple and used to greet a person. It takes the name of the person as input and out as "Hello, {name}."

Open the [website] file and add a comment as below:

As soon as we hit enter, we see the code generated. Now press the tab, and we will see that the API code is generated. That's the advantage of using Copilot.

Similarly, let's create another simple API that takes two integer values as input and returns the multiplication by using Copilot. This time we will try it in the right pallet of VSCode rather than in the [website] file.

Python # Create an endpoint to multiply two numbers. [website]'/multiply') def multiply(): try: num1 = float([website]'num1')) num2 = float([website]'num2')) result = num1 * num2 return f'The result of {num1} * {num2} is {result}' except (TypeError, ValueError): return 'Invalid input. Please provide two numbers as query parameters.'

However, I see a different code was generated when I asked Copilot to write the API inside the [website] file. See below:

Python # Create an endpoint to multiply two numbers. [website]'/multiply//') def multiply(num1, num2): return f'{num1} * {num2} = {num1 * num2}'

The reason here is based on the previous context it generates the code. When we were on the [website] file and asked the Copilot to generate the API code, it generated based on the context that the API should have two inputs and return the output. But when we requested to generate in the right palate, it generated based on the previous question with the context that it's a flak app, and input will come from the request param. So here, we can safely conclude that based on previous context, it will generate the next output.

Now, both our APIs are ready, so let's deploy the app and test it. But we have not installed Flask yet. So, let's do that.

1. Activate the virtual environment and install Flask.

When we run the application, we see an issue in the startup due to the generated code. Below is the error:

Plain Text File "/people/sibasispadhi/Documents/coding/my-flask-app/venv/lib/[website]", line 72, in find_best_app app = app_factory() ^^^^^^^^^^^^^ File "/people/sibasispadhi/Documents/coding/my-flask-app/app/[website]", line 14, in create_app app.register_blueprint([website] ^^^^^^^^^ AttributeError: module '[website]' has no attribute 'bp' (venv) sibasispadhi@Sibasiss-Air my-flask-app %.

The create_app function in our project's app/[website] file is calling app.register_blueprint([website] , but the [website] file doesn’t have bp (Blueprint object) defined.

Below are the changes done to fix the problem. (See the code commented is the one autogenerated).

Python # Register blueprints from . import routes # app.register_blueprint([website] app.register_blueprint([website].

Re-running the application will successfully deploy the application, and we are ready to test the functionality. The APIs can be tested using Postman.

2. Testing through Postman gives the results successfully.

GitHub Copilot generates the project and the boilerplate code seamlessly and it saves development time and effort. It's always advised to review the generated code so that it matches developers' expectations. Whenever there is an error, we must debug or request Copilot further suggestions to solve the problem.

In this project, Copilot helped us create and run a stateless Flask microservice in no time. We faced some initial hiccups, which were solved after debugging, but overall, the development time was faster. I would suggest all readers start exploring Copilot today and enhance their day-to-day productivity.

Stay tuned for my next set of articles on Copilot, where we will dive deep into more real-world scenarios and see how it solves our day-to-day tasks in a smooth manner.

Apache Kafka is known for its ability to process a huge quantity of events in real time. However, to handle millions of events, we need to follow cert......

Hey I'm building Devunus, a developer tools suite for feature flags and analytics, and I'd love to share my technical journey and get your feedback.

If you've ever needed some random data for testing or just wanted to add a bit of fun to your p......

Build a URL Shortener With Neon, Azure Serverless Functions

Neon is now available on the Azure marketplace. The new integration between Neon and Azure allows you to manage your Neon subscription and billing through the Azure portal as if Neon were an Azure product. Azure serverless and Neon are a natural combination — Azure serverless frees you from managing your web server infrastructure. Neon does the same for databases, offering additional attributes like data branching and vector database extensions.

That unveiled, let's try out this new integration by building a URL shortener API with Neon, Azure serverless, and [website].

Note: You should have access to a terminal, an editor like VS Code, and Node v22 or later installed.

We are going to have to do things a little backward today. Instead of writing the code, we will first first set up our serverless function and database.

Step 1. Open up the Azure web portal. If you don’t already have one, you will need to create a Microsoft account.

Step 2. You will also have to create a subscription if you don’t have one already, which you can do in Azure.

Step 3. Now, we can create a resource group to store our serverless function and database. Go to Azure's new resource group page and fill out the form like this:

This is the Azure Resource Group creation page with the resource group set to "AzureNeonURLShortener" and the location set to West US 3.

In general, use the location closest to you and your clients, as the location will determine the default placement of serverless functions and what areas have the lowest latency. It isn’t vital in this example, but you can search through the dropdown if you want to use another. However, note that Neon doesn’t have locations in all of these regions yet, meaning you would have to place your database in a region further from your serverless function.

Step 5. Now, we can create a serverless function. Unfortunately, it includes another form. Go to the Azure Flex consumption serverless app creation page and complete the form. Use the resource group previously created, choose a unique serverless function name, place the function in your resource group region, and use Node v20.

Step 3. You will be redirected to a login page. Allow Neon to access your Azure information, and then you should find yourself on a project creation page. Fill out the form below:

The project and database name aren't significant, but make sure to locate the database in Azure West US 3 (or whatever region you choose). This will prevent database queries from leaving the data center, decreasing latency.

Make sure you don’t lose this, as we will need it later, but for now, we need to structure our database.

SQL CREATE TABLE IF NOT EXISTS urls(id char(12) PRIMARY KEY, url TEXT NOT NULL);

Step 1. First, we must install Azure’s serverless CLI, which will help us create a project and eventually test/publish it. Open a terminal and run:

Plain Text npm install -g azure-functions-core-tools --unsafe-perm true.

Step 2. If you want to use other package managers like Yarn or pnpm, just replace npm with your preferred package manager. Now, we can start on our actual project. Open the folder you want the project to be in and run the following three commands:

Plain Text func init --javascript func new --name submit --template "HTTP trigger" func new --name url --template "HTTP trigger" npm install nanoid @neondatabase/serverless.

Now, you should see a new Azure project in that folder. The first command creates the project, the two following commands create our serverless API routes, and the final command installs the Neon serverless driver for interfacing with our database and Nano ID for generating IDs. We could use a standard Postgres driver instead of the Neon driver, but Neon’s driver uses stateless HTTP queries to reduce latency for one-off queries. Because we are running a serverless function that might only process one request and send one query, one-off query latency is essential.

You will want to focus on the code in src/functions, as that is where our routes are. You should see two files there: [website] and [website].

[website] will store the code we use to submit URLs. First, open [website] and replace its code with the following:

TypeScript import { app } from "@azure/functions"; import { neon } from "@neondatabase/serverless"; import { nanoid } from "nanoid"; const sql = neon("[YOUR_POSTGRES_CONNECTION_STRING]"); [website]"submit", { methods: ["GET"], authLevel: "anonymous", route: "submit", handler: async (request, context) => { if (![website]"url")) return { body: "No url provided", status: 400, }; if (!URL.canParse([website]"url"))) return { body: "Error parsing url", status: 400, }; const id = nanoid(12); await sql`INSERT INTO urls(id,url) VALUES (${id},${[website] "url" )})`; return new Response(`Shortened url created with id ${id}`); }, });

Let’s break this down step by step. First, we import the Azure functions API, Neon serverless driver, and Nano ID. We are using ESM (ES Modules) here instead of CommonJS. We will need to make a few changes later on to support this.

Next, we create the connection to our database. Replace [YOUR_POSTGRES_CONNECTION_STRING] with the string you copied from the Neon dashboard. For security reasons, you would likely want to use a service like Azure Key Vault to manage your keys in a production environment, but for now, just placing them in the script will do.

Now, we are at the actual route. The first few properties define when our route handler should be triggered: We want this route to be triggered by a GET request to submit.

Our handler is pretty simple. We first check if a URL has been passed through the URL query parameter ([website], /submit?url=[website]), then we check whether it is a valid URL via the new URL.canParse API. Next, We generate the ID with Nano ID. Because our IDs are 12 characters long, we have to pass 12 to the Nano ID generator. Finally, we insert a new row with the new ID and URL into our database. The Neon serverless driver automatically parameterizes queries, so we don’t need to worry about malicious consumers passing SQL statements into the URL.

[website] is where our actual URL redirects will happen. Replace its code with the following:

TypeScript import { app } from "@azure/functions"; import { neon } from "@neondatabase/serverless"; const sql = neon("[YOUR_POSTGRES_CONNECTION_STRING]"); [website]"redirect", { methods: ["GET"], authLevel: "anonymous", route: "{id:length(12)}", handler: async (request, context) => { const url = await sql`SELECT * FROM urls WHERE [website]${[website]}`; if (!url[0]) return new Response("No redirect found", { status: 404 }); return Response.redirect(url[0].url, 308); }, });

The first section of the script is the same as [website] Once again, replace it \[YOUR\_POSTGRES\_CONNECTION\_STRING\] with the string you copied from the Neon dashboard.

The route is where things get more interesting. We need to accept any path that could be a redirect ID, so we use a parameter with the constraint of 12 characters long. Note that this could overlap if you ever have another 12-character route. If it does, you can rename the redirect route to start with a Z or other alphanumerically greater character to make Azure serverless load the redirect route after.

Finally, we have our actual handler code. All we need to do here is query for a URL matching the given ID and redirect to it if one exists. We use the 308 status code in our redirect to tell browsers and search engines to ignore the original shortened URL.

There are two more changes we need to make. First, we don’t want a /api prefix on all our functions. To remove this, open [website], which should be in your project directory, and add the following:

TypeScript "extensions": { "http": { "routePrefix": "" } }.

This allows your routes to operate without any prefixes. The one other thing we need to do is switch the project to ES Modules. Open [website] and insert the following at the end of the file:

Now, you can try testing locally by running func start . You can navigate to [website]:7071/submit?url=[website], then use the ID it gives you and navigate to [website]:7071/[YOUR_ID]. You should be redirected to [website].

Of course, we can’t just run this locally. To deploy, we need to install the Azure CLI, which you can do with one of the following commands, depending on your operating system:

Plain Text winget install -e --id Microsoft.AzureCLI.

Now, restart the terminal, log in by running az login, and run the following in the project directory:

Plain Text func azure functionapp publish [FunctionAppName].

Replace [FunctionAppName] with whatever you named your function earlier.

Now, you should be able to access your API at [FunctionAppName][website] .

You should now have a fully functional URL Shortener. You can access the code here and work on adding a front end. If you want to keep reading about Neon and Azure’s functions, we recommend checking out Branching. Either way, I hope you learned something valuable from this guide.

There are times when a new feature containing sorting is introduced. Obviously, we want to verify that the implemented sorting works correctly. Assert......

In January 2024, Flux faced a funding problem. Its progenitor, WeaveWorks, could no longer support the project or its maintainers. At ControlPlane, we......

Cummins: I'm Holly Cummins. I work for Red Hat. I'm one of the engineers who's helping to build Quarkus. Just as a level set before I star......

Productivity and Organization Tips for Software Engineers

I’ve been a software engineer for a little over a decade now, and I like to think I’m a pretty organized person. I have a system for everything, and these systems help my mind and my day run more smoothly.

Organization isn’t something that comes naturally to everyone, so today, I thought I’d share some of my strategies that help me have a productive and fulfilling work day.

I’ve organized them below sequentially, walking you through how I start my day, the things I do throughout my day, and how I end my day.

To get oriented each morning, I check several things:

This usually takes just 5 to 10 minutes and helps me get ready for everything going on that day.

If I have an interview to conduct, I’ll block off time on my calendar before the interview to prepare and after the interview to submit my feedback. If I have a 1on1 with my manager, I’ll add an item to my to-do list to prepare notes for what I want to talk about.

If I have emails or Slack messages that need my attention, I’ll either respond to them right away or add an item to my to-do list. As a rule of thumb, if the message only takes a couple of minutes to respond to or take care of, I’ll just do it right away. If it’s something that will take longer, like someone asking me to review a pull request or a tech spec, I’ll add that to my to-do list.

Next, I go through a small routine of morning tasks. This involves saying good morning to my teammates over Slack (we’re all remote) and sending out a short morning study of noteworthy things going on that day.

The morning analysis usually includes our sprint goals, pull requests, tech specs needing review, and any relevant upcoming events or action items. The morning analysis only takes a couple of minutes to write, and it helps keep everyone on the team on the same page.

I’m passionate about web accessibility, so each morning, I also send out a short “ of the Day” in Slack. of the day is a short tidbit of info, usually focused on engineering, product, and design. I’ve been doing this for about a year and a half now, and I’ve written 300 tips so far! (You can find them on LinkedIn under the hashtag #accessibilityTipOfTheDay).

At this point, I’m usually about a half hour into my day. If there are any tasks that urgently need to be done, and they can be done quickly, I’ll try to knock out several small things in the next half hour. This usually includes short pull request reviews. I always appreciate people quickly reviewing my code, so I try to do the same. This helps unblock other engineers who are waiting on a review, and it helps keep the work moving along.

What the rest of my day looks like will vary based on how many meetings I have or if I have an interview to conduct, but on my to-do list, I always have one big thing: that’s my main goal for the day. If I can get this one thing done, I’ll consider it a successful day. This could be something like completing an crucial Jira task, writing an RFC, or finishing a blog post draft for our engineering blog. Whatever the task is, it’s usually something that I need 2–3 hours of uninterrupted time to complete.

This “one big thing” strategy has a lot of different names, and you may be familiar with ideas like:

Paul Graham’s essay “Maker’s Schedule, Manager’s Schedule,” where he argues that software engineers (“makers”) need about a half day of uninterrupted time to get any meaningful work done.

Brian Tracy’s book Eat That Frog!, where he encourages you to do the hardest thing in your day first.

Mihaly Csikszentmihalyi’s book Flow, which describes a “flow” state of intense enjoyment, creativity, and/or productivity in which you lose yourself in what you’re doing.

Oliver Burkeman’s 3-3-3 method, in which he advocates for spending three hours on an essential task, doing three smaller tasks, and doing three maintenance tasks each day.

The rocks and sand in a jar analogy, which teaches that you should focus on the big crucial things first (If you have large rocks, small rocks, sand, and a jar, the order in which you put the items in the jar matters. If you put the sand and small rocks in the jar first, you’ll find that the large rocks don’t fit. But if you put the large rocks in first, then the small rocks, and next the sand, you’ll find that there’s room for all of them. Prioritize the big crucial things, and there will be room for the rest.).

I dislike context switching, so after I’ve finished my one big thing, I’ll do a batch of smaller things all in a row. This could be reviewing more pull requests, writing or improving a wiki, reviewing a tech spec, responding to new messages, completing a shorter Jira task, or reading a short blog post.

I learn best through written communication. I’d much rather read something than watch a video or have a meeting, and I’m much improved at organizing my thoughts when I write them down.

For just about any task I work on, I open a scratch pad in my Notes app to jot down my thoughts. When working on an engineering task, I might write down bullet points of what the problem is and how I’m planning on solving it. When troubleshooting something, I’ll write down the steps I took and what did or didn’t work. This helps me work through problems and also makes it really easy to send my notes to other engineers if I need help.

This written log usually isn’t something that I ever need to look at again after I’ve finished the task, but it does sometimes come in handy when I encounter a similar problem in the future and want to see how I solved it in the past.

I’ve mentioned my to-do list already, which I create and review each morning. Throughout the day, if a thought pops into my head for something I should do, I add it to my to-do list right away. This allows me to go back to whatever I’m actively working on without needing to worry about remembering this other new thing.

I’ve found that the more information I can get out of my head and written down, the less cognitive load I have, and the less I need to remember.

You can get a lot more done in a day if you do things in the “right” order. For example, if I know that I have two hours of meetings in the afternoon, I try to get a pull request ready before then. That way, someone can review my code while I’m in meetings, and (hopefully) my pull request will be ready to be merged as soon as I get out of my last meeting.

Similarly, if I can get something up for review in the morning, that leaves time for me to switch to other smaller tasks while I wait for a review (the rocks and sand in a jar analogy).

I end my work day in much the same way that I start it. Before signing off, I review my calendar for tomorrow and add items to tomorrow’s to-do list.

Both of these things are a shutdown routine to help clear my mind so I don’t keep thinking about work for the rest of the day. If a work thought does pop into my head during the evening, I’ll quickly write that down on my to-do list so I don’t have to worry about trying to remember it tomorrow. This helps reduce the cognitive load, lets me focus on my family, and also ensures that I don’t lose any “aha” moments when a sudden stroke of insight occurs.

I’ve more or less followed this routine for years now, and it’s helped me immensely. I hope something in this piece has resonated with you and will help you, too! Thanks for reading.

Apache Kafka is known for its ability to process a huge quantity of events in real time. However, to handle millions of events, we need to follow cert......

In January 2024, Flux faced a funding problem. Its progenitor, WeaveWorks, could no longer support the project or its maintainers. At ControlPlane, we......

Hey friends, today we will do a short introduction how to run envoy proxy with docker. We will work with the basic blocks of envoy, which are listener......