DEV Community: Agustinus Theodorus

How to Deploy Flutter Web to Netlify Using CI/CD and Azure Pipelines

Agustinus Theodorus — Wed, 20 Jan 2021 14:44:42 +0000

Developing web apps has become easier over the years. With Flutter it became very easy and fun. But to be honest, deploying it is sometimes a pain. Most services are not ready for Flutter projects being hosted on the web. Sure, some are but it needs a bit of tinkering.

I don’t mind tinkering a bit, I mean… Why not?

Here in this tutorial, I am going to share with you how to implement CI/CD on your Flutter web deployments using Azure DevOps Pipelines. And best of all, we are going to use Netlify! Why do I sound excited? Because honestly, Netlify is very easy to use. Now, without further ado let’s get to it.

Installing Dependencies

Before we start, we need to install the required dependencies beforehand.

1. Installing the Flutter plugin

Well, you can use the Flutter plugin for DevOps a dev already made the tool for us. Thanks, Aloïs for doing the heavy work! We can use this tool for our purpose.

After clicking that button, you would be shown on this screen:

Now in what you have to do is:

Choose the organization you want to install.
Click install.

2. Installing the Nelitfy plugin

Install the Netlify plugin for DevOps. Thanks, Aliencube for doing the heavy work! We can use this tool for our purpose.

After clicking that button, you would be shown on this screen:

Now in what you have to do is:

Choose the organization you want to install.
Click install.

Creating your Netlify site

This section will discuss how you can create an empty Netlify site using Netlify CLI. We will be using npm to install it for us. In my case, I use Ubuntu 18.04 as the host OS for the npm installation.

1. Install Netlify CLI

To install Netlify CLI you just need to run:

npm install netlify-cli -g

After the installation is complete, check if it’s installed correctly by running this command:

netlify

2. Log in to Netlify from the CLI

Before you can start using the CLI, Netlify needs you to authenticate yourself.

netlify login

Then a browser window will open:

3. Creating a blank site

After finishing your login, create a blank site using this command:

netlify sites:create --name _<site name>_

4. Retrieving your Site ID and personal access token

To run continuous development remotely you would need both your site ID and personal access token to help you

Retrieve your Site ID by:

Going into the site settings.
Copy the API ID value.

The next step would be to retrieve the personal access token.

Go to the User settings.

To get an access token, you would have to make a new one:

Go to the Applications tab.
Click New access token.

Copy and save the access token shown on the next screen, and save it because you will need it for later.

Creating the CI/CD Pipeline

This part is my favorite because it uses Azure DevOps. I honestly love the pipeline building experience using the UI (e.g the classic editor). But how do you build Flutter projects using Azure DevOps you ask?

1. Creating the CI pipeline

If you are using Azure DevOps there is no way we can attach a CI/CD pipeline from Netlify’s side as with Github, Gitlab, or Bitbucket. So, we have to get down and dirty and do it ourselves (well with a little help).

First, create your pipeline:

Click on Pipelines on the left pane.
Open the Pipelines directory.
Click New pipeline.

Now the beautiful thing about Azure DevOps is they have a UI for all of this, so you don’t need to use YAML at all. Though you can generate YAML code from the UI. Using the classic editor, you don’t have two remember YAML syntaxes and can easily make deployment steps using the visuals.

You can always configure using YAML in other services, but let’s face it, using UI is so much better. To enable pipeline configurations using the UI, when you are creating your pipeline click the small use classic editor link below:

After selecting the classic editor, configure your project:

These configurations would be needed to state which project you will be using in the pipeline, start by:

Selecting Azure Repos Git, to select repositories from Azure DevOps.
Selecting your team project.
Selecting the repository you want to CI.
Select the repository branch.
Click continue.

Select the Empty job button to create a clean slate for our Flutter deployment configuration.

After Agent job 1 show up you need to:

Click the + button to add new tasks in the pipeline.
Search for Flutter Install.
Click Flutter Install.

After adding Flutter install we can add the Flutter test task to enable testing in our pipeline before being built and deployed. But because I prepared a small app and I am focusing on deployments I wouldn’t be adding testing to the task list.

Next, add two Flutter Command tasks to the pipeline. FYI, tasks are forms of stages deliberately visualizing how our CI/CD pipeline connects.

Let’s face it, using UI is so much better.

The first Flutter Command task will be to enable web configurations (i.e allow builds for web projects).

Click the Flutter Command task.
Change the display name to Flutter Enable Web (optional).
Add the Flutter arguments to enable web configurations:

config --enable-web

To build the web project, we have to run it manually using the Flutter Command task.

Click the Flutter Command task.
Change the display name to Flutter Run Build Web (optional).
Add the Flutter arguments to build web projects:

build web

Add a new task to Copy files :

Click the + button to add a new task.
Search for copy files.
Add the Copy files task.

After we build the project, build files will need to be copied to the artifacts directory:

Click the Copy Files task.
Change the source folder to $(Build.SourcesDirectory)/build/web.
Change the target folder to $(Build.ArtifactStagingDirectory).

Add a new task to Publish build artifacts :

Click the + button to add a new task.
Search for publish build artifact.
Add the Publish build artifacts task.

After adding the Publish build artifacts task you can change the name of the artifact after publishing in this case I changed it to ci-artifact.

When all is done, save the CI pipeline.

TL;DR If you want to use YAML you can copy and paste this YAML file here:

pool:
  name: Azure Pipelines
steps:
- task: aloisdeniel.flutter.flutter-install.FlutterInstall@0
  displayName: 'Flutter Install'

- task: aloisdeniel.flutter.flutter-command.FlutterCommand@0
  displayName: 'Flutter Enable Web'
  inputs:
    arguments: 'config --enable-web'

- task: aloisdeniel.flutter.flutter-command.FlutterCommand@0
  displayName: 'Flutter Run Build Web'
  inputs:
    arguments: 'build web'

- task: CopyFiles@2
  displayName: 'Copy Files'
  inputs:
    SourceFolder: '$(Build.SourcesDirectory)/build/web'
    TargetFolder: '$(Build.ArtifactStagingDirectory)'

- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact: ci-artifact'
  inputs:
    ArtifactName: 'ci-artifact'

2. Creating the CD pipeline

The continuous deployment section will be used to push our builds directly to Netlify. This part is similar to most JAMStack apps such as React, Vue, Next, and Flutter Web. An article by Clyde D’Souza influenced this particular section. But of course, I modified it slightly because the project we’re using is a Flutter project.

Open the releases pipeline, click on the Releases tab on the left side of the screen:

Click the Pipelines on the left side of the tab.
Open Releases.
Click New.
Click New release pipeline.

Create an empty job.

Connect your CD pipeline with your CI pipeline:

Add an artifact.
Select your project.
Choose your CI pipeline
Add the pipeline.

Enable the continuous deployment trigger to start after a successful build:

Click the lightning logo to open the trigger page.
Click the Enabled button.

Add a new task to the new CD pipeline:

Open your Tasks tab.
Click the + button.
Search for Extract files.
Add the task to the pipeline.

Extract the artifacts according to the build Id.

Add a new task to the new CD pipeline:

Click the + button.
Search for Netlify.
Add the Install Netlify CLI task to the pipeline.

Add a new task to the new CD pipeline:

Click the + button.
Search for Netlify.
Add the Deploy Website task to the pipeline.

To connect our CD pipeline to our Netlify site, we need to have our access tokens and our site ID. We utilize pipeline variables to make it more accessible and provide secrecy to the token.

Click the + Add button twice.

You will be shown with 4 input boxes. Put the name of the variable inside the left boxes and the values in the right. For convenience name the access token variable PAT, and name the other variable SiteID respectively.

Change the deployment configuration:

Click Deploy to Netlify.
Insert your access token.
Insert the Site ID.
Select the build source directory.

Your CD pipeline should be finished, save the pipeline and try running it yourself! You can check the dummy site I deployed here.

Summary

In this tutorial, you have learned how to Flutter web deployments using CI/CD and Azure DevOps. We then deployed the site on Netlify.

To recap what we have done:

Installed the Flutter and Netlify dependencies.
Created a blank site on Netlify.
Retrieved the authorization token and site ID from Netlify.
Prepared the CI/CD Pipelines.

You now have an open playbook to use when you want to automate deployments. In the next tutorial, we will be looking into how we can utilize Github Actions to make a CI/CD pipeline for Flutter Web and Netlify.

Setting Up A Multinode RabbitMQ Cluster On Linux

Agustinus Theodorus — Tue, 19 Jan 2021 17:51:10 +0000

Installing RabbitMq on multiple remote servers can be a hassle. To connect multiple instances into one cluster we must first install RabbitMq on each remote server. These next two steps will walk through how we can install RabbitMq instances.

In this tutorial, we will be installing RabbitMq using a Centos 8 Linux distro. The RabbitMq version used in this tutorial is 3.8.9.

What is clustering for?

Well, clustering is used to combine multiple instances of RabbitMq into one giant central message queue. Clustering can be done on remote instances of RabbitMq on different servers. The purpose of the cluster is to handle massive amounts of message queues from apps, balancing the load on multiple servers rather than on a single server.

Add the required dependencies

Install the required repositories

Add the RabbitMq repository in the repo configurations file. Open the config file:

sudo vi /etc/yum.repos.d/rabbitmq-server.repo

Add this to the lines below:

[rabbitmq-server]  
name=rabbitmq-server  
baseurl=[https://packagecloud.io/rabbitmq/rabbitmq-server/el/7/$basearch](https://packagecloud.io/rabbitmq/rabbitmq-server/el/7/$basearch)  
repo_gpgcheck=1  
gpgcheck=0  
enabled=1  
gpgkey=[https://packagecloud.io/rabbitmq/rabbitmq-server/gpgkey](https://packagecloud.io/rabbitmq/rabbitmq-server/gpgkey)  
sslverify=1  
sslcacert=/etc/pki/tls/certs/ca-bundle.crt  
metadata_expire=300

Add Hostname to the `hosts` file

RabbitMq is built on top of Erlang. So it would make sense for us to install it beforehand. This part is very crucial as if you do not ad the hostname to /etc/hosts then rabbitmqctl status will not work.

echo “127.0.0.1 $(hostname -s)” | sudo tee -a /etc/hosts

Setting Up RabbitMq Server

Install RabbitMq Server

After completing the previous configuration setup steps, install RabbitMq by using this command:

sudo dnf install -y rabbitmq-server

After installation is completed, check if the installation is correct by running:

rpm -qi rabbitmq-server

Open Ports

Centos has a pre-installed firewall called firewalld. It blocks all ports from connecting unless asked to. So we must whitelist the TCP ports that are going to be used by RabbitMq.

sudo firewall-cmd --zone=public --permanent --add-port={5672,15672}/tcp  
sudo firewall-cmd --reload

Start the RabbitMq service

The RabbitMq service doesn’t start on its own when you install it. You have to start it manually, then enable it to run on server startup. To start the RabbitMq service (the service might take a minute or two to start):

sudo systemctl start rabbitmq-server.service

To enable the service run:

sudo systemctl enable rabbitmq-server.service

To check if the service is still running:

sudo rabbitmqctl status

Enable RabbitMq Management

If you want to enable the RabbitMq admin dashboard, run:

sudo rabbitmq-plugins enable rabbitmq_management

Then try to open the dashboard from the browser:

http://*your-server-ip*:15672

Setting Up RabbitMq Cluster

After setting up RabbitMq on multiple servers (minimum of 2 servers) we now can continue to set up instances for the master and slave nodes. Choose one server as the master node as the cluster host, then use the other nodes as a slave cluster.

Setting Up The Master Node

Whitelist the TCP port 4369 for epmd, a helper discovery daemon used by RabbitMQ nodes and CLI tools, and port 25672 for instance finding.

sudo firewall-cmd —-zone=public —-permanent —-add-port={4369,25672}/tcp  
sudo firewall-cmd —-reload

Add the hosts for each cluster, in the /etc/hosts file

sudo vi /etc/hosts

In the hosts file add the IP and hostname for each instance. The configuration would be as follows:

node 1 IP node 1 hostname  
node 2 IP node 2 hostname  
node 3 IP node 3 hostname

The order doesn’t have to be master first, but it does need to have all cluster IPs and hostnames for it to work. An example configuration is as follows:

10.240.200.111 rabbitmq-1  
10.240.200.112 rabbitmq-2  
10.240.200.113 rabbitmq-3

Get the .erlang.cookie from the master node

sudo cat /var/lib/rabbitmq/.erlang.cookie

Save the token output in your notepad.

Setting Up The Slave Nodes

Whitelist the TCP port 4369 for epmd a helper discovery daemon used by RabbitMQ nodes and CLI tools, and port 25672 for instance finding.

sudo firewall-cmd —-zone=public —-permanent —-add-port={4369,25672}/tcp  
sudo firewall-cmd —-reload

Add the hosts for each cluster, in the /etc/hosts file

sudo vi /etc/hosts

In the hosts file add the IP and hostname for each instance. The configuration would be as follows:

node 1 IP node 1 hostname  
node 2 IP node 2 hostname  
node 3 IP node 3 hostname

The order doesn’t have to be master first, but it does need to have all cluster IPs and hostnames for it to work. An example configuration is as follows:

10.240.200.111 rabbitmq-1  
10.240.200.112 rabbitmq-2  
10.240.200.113 rabbitmq-3

Stop the rabbitmq-server instance and replace the .erlang.cookie inside the slave node with the masters.

sudo su  
systemctl stop rabbitmq-server  
echo -n “*erlang cookie from master node*” > /var/lib/rabbitmq/.erlang.cookie  
systemctl start rabbitmq-server

Repeat this setup on all the nodes!

Join The Slave Nodes With The Master Node

Stop the rabbitmq-server instance, reset the node and join it with the master node.

sudo rabbitmqctl stop_app  
sudo rabbitmqctl reset  
sudo rabbitmqctl join_cluster rabbit@*master node hostname*  
sudo rabbitmqctl start_app

Reset The Master Node

Reset the rabbitmq-server in the master node.

sudo rabbitmqctl stop_app  
sudo rabbitmqctl reset  
sudo rabbitmqctl start_app

Check The Cluster Status

To check the cluster status, run this command:

sudo rabbitmqctl cluster_status

Conclusion

In the end, when we have finished installation, login to the RabbitMq management dashboard for one of the nodes and it would have more than one cluster like so:

undefined

Of course, there are advantages in using manual installs for RabbitMq. The pros would be:

You can save space on each server by only installing RabbitMq and nothing else.
Particularly on VMs, you can use Ansible to speed up the installation process by doing the repeatable tasks from a single command line.
You understand thoroughly the process of building a RabbitMq instance from the ground up.

Then the cons would be:

Managing the firewalls for each server can be complicated.
It is faster for us to use Docker during container set up for each server.

But if you want to read more on this topic, and read some of the references I had when making this tutorial you can check out these links below:

Official RabbitMQ Clustering Guide.
How to Install RabbitMQ on RHEL 8 / CentOS 8 — Linux Windows and android Tutorials (osradar.com).
[How to config rabbitmq server cluster 3 nodes](https://gist.github.com/pobsuwan/22aa4a9e0a217d22e12800a432933881).

Now we have an open playbook for you to use the next time you want to setup RabbitMq on your systems manually.

The Microservice Architecture Perspective

Agustinus Theodorus — Thu, 31 Dec 2020 16:51:07 +0000

Making software that serves more than a couple of thousand users can be hard. The difficulty is not in making the app itself but in how we make the app reliable. Microservices is a solution to messy problems like these. Instead of relying on one large server, we use a bunch of small ones to solve our problem. To elaborate on this subject further here are a few perspectives I have on the microservices architecture.

One Down, Many More To Go

In my honest opinion, one of the reasons I go with a microservice is the reliability factor. With multiple servers, this can be the case. We add reliability to the service by adding more of them. This technique is called load balancing.

Instead of burdening all the traffic to one server, you can balance it to multiple servers. So it can be nearly impossible to down the service. The best part of this is that you don’t need to have expensive high throughput servers to make this happen. For example, you can host your server on a few digital ocean droplets, instead of one large one.

Though load balancing alone cannot determine a microservice, there are other characteristics that would need to be fulfilled. This is but only one of the advantages of the microservice pattern.

If you are using a monolith pattern logically you can still use load balancing, the only downside would be that you would need multiple high throughput servers to serve your app. Multiplying the cost.

Pay For What You Need

Before I start, let me say. This section is debatable. I am explaining this from my point of view and my previous experiences. Because when your entire service is determined by small services, it can be easy to cut costs. We can buy only the things that we need.

For explanation purposes let’s say a 1 GB droplet can handle about 1k users. So to handle 5k users you probably would need to use the 8GB droplet for the price of $40 a month.

Instead, you can use 3 droplets. Two 1 GB droplets and one 4 GB droplet for $30 a month. We buy two 1 GB droplets so we can use one for the service and use the other one for load balancing. With this scheme, you saved $10 a month.

This is a very simple example. A better one would be when we have separate microservices that connect to each other, we can tune the prices to our exact use of computing power.

For example, the donuts API may have more load than the coffee API. We can then scale up the donuts API server to be able to handle those requests. Being able to specify upgrades by service can help reduce costs tremendously.

Separate Your Interests

Monoliths have this habit of merging all services together, related or not. This causes a problem when one of the services goes down, it will take the entire app down with it. If you value reliability, you wouldn’t want that.

Using the microservice architecture each service can be separated, making it independent of one another. This type of API development is called domain driven development or DDD. It is a very interesting way of designing systems small that can scale big. You can read more about DDD here. Reading more into this topic might lead you to cool system design patterns like CQRS, Database per service, and API Composition.

The picture above explains my point perfectly. Connections from the client would be made to a gateway/edge API. The edge API would then connect to the multiple microservices available for each specific request. With the corresponding databases behind each specific API.

Say, the user wants some books, of course, the data would be retrieved from the books API. After seeing the catalog of books, the user made up their mind and wishes to check out. The user is then connected to the check out API. Notice that all the services are independent of each other it does not coincide with one another other than the edge API. It adds reliability to the app.

Scale More!

Why does this section have an exclamation mark? Because this is the main gist of using microservices. It is the best feature anyone could have asked for. Put reliability and scalability together and what do you have? A great user experience.

Not all companies might need the blessing of microservices but for those that do it really does make a huge difference. All the sections before this one support this. Separable domains, cost-effectiveness, and reliability.

But you do not need to scale everything. When you are building a team of services using microservices will help you in the long run, but when you are making an MVP or some other small apps you would not need to implement microservices at all. It might even slow you down!

Microservices is not the grand bullet for everything, even though it has both reliability and scalability to its name. It has good things to offer for select cases, not for everyone.

Small and Compact

Microservices like the name entails are very small apps that communicate with each other. With specificity in mind, teams can deploy new services quickly without breaking another.

This coincides perfectly with agile teams that want to reach a certain target. Deployments are easy because it allows for easy and straightforward testing. You only need to test the things that you deploy, there is no need to test the other services along with it.

Almost all the articles I’ve read about microservices applaud the ease of deployments this architecture has to offer. Though that’s not all the benefits of being small and compact.

Maintainability wise, it will be much easier than monoliths. The functions are simple because the folders aren’t merged into one project. Honestly from my own experience handling a monolith, traversing the folders was very difficult. Filenames can sometimes be similar in a way that I confuse which service is which.

Sure, people can say that a confusing monolith project reeks of bad code management. When you have more than 100 features in a project it does tend to get a little messy. Add to the number of teams responsible for different features contributing to the same codebase 🤯.

I can only imagine the number of branches that repo has…

More Autonomy and Faster Development Speeds

With microservice, this doesn’t have to be. Microservice brings more autonomy to the team. Working together between teams is not easy. We have our own schedules that we need to attend. But when we use the microservices concept, the pain of inter-team management becomes invisible.

All you need would be a coding standard, and you would be good to go. Though more autonomy, coupled with faster development could lead to trouble if you don’t have good documentation.

Let me make this clear, working autonomously is great and all. But in the end, you still need to communicate. What better way to miscommunicate other than having no documentation. Believe me, I have experienced these kinds of things first hand. Microservices does not solve problems like these.

With more autonomy teams can be more business-oriented with their goals, timelines become much shorter and development can focus more on new features.

With Great Power Comes Great Documentation

Elaborating from the previous section, a good analogy for microservices would be “With great power comes great responsibility”. I am not kidding, when you have tons of services you would wish for good documentation. For a good perspective here is an illustration of the Netflix microservice backend.

Now imagine, how much of that would you remember. The answer is none. That’s why documentation is important. Probably using Netflix as an example is a huge exaggeration — but hey it gets the point across.

Now I know — every application needs documentation. That’s true but it becomes double for microservices. There are benefits to good documentation though. The better documented the microservice is, the reusable probability of each service will be increased. This brings us to the next point.

Reusability

What I love about writing code is how much less of it I have to write. Get what I am saying? Reusable components, reusable APIs, reusable everything! I would integrate every one of my apps into one large system, and if I can reuse some parts of it for another app I would do it without notice.

The part that I like about microservices is that it’s very portable, I mean one service can be accessed by many. That’s why I usually try to make microservices as general as I can make it — doesn’t mean that I won’t make it specific when I need to. It just comes as a natural thing to do to reuse things you made.

Conclusion

To summarize microservice architectures are usually used to help increase the reliability of a system. The benefits of using a microservice architecture are as follows:

Made to be reliable.
Pay for what you need.
Write separate applications for each domain.
Have a nature to scale.
Small and compact.
Separated development for teams that wants to move fast.
Reusability factor.

Though the microservice architecture does come with its faults. The disadvantages of using a microservice are as follows:

With great power, comes great documentation.
Small companies with few teams are not suitable for this architecture.
Does not fit every business model (e.g monoliths are better for MVPs).
Because it has a nature to scale, it can become bloated if not checked. We can’t all be like Netflix.

This was my perspective regarding microservices. I hope it was clear enough of an explanation.

Automating Flutter Web Deployments to Netlify Using GitHub Actions

Agustinus Theodorus — Mon, 28 Dec 2020 16:18:18 +0000

Lately, there has been a lot of fuss over Flutter. Some people call it the future, while some say it’s overrated. But I think it’s a good framework to learn nonetheless. The sheer amount of things that can be done with Flutter is unbelievable, including Android, iOS, desktop, and web programming.

Here in this tutorial, I’m going to share how to implement your Flutter web deployments using GitHub Actions. Also, we’re going to use Netlify. Why Netlify? Because, honestly, Netlify is very easy to use. Now, without further ado, let’s get to it.

Creating Your Netlify Site

This section will discuss how you can create an empty Netlify site using the Netlify CLI. We’ll be using npm to install it for us. In my case, I use Ubuntu 18.04 as the host OS for the npm installation.

1. Install the Netlify CLI

To install the Netlify CLI, you just need to run:

npm install netlify-cli -g

After the installation is complete, check if it’s installed correctly by running this command:

netlify

2. Log in to Netlify from the CLI

Before you can start using the CLI, Netlify needs you to authenticate yourself.

netlify login

Then a browser window will open:

3. Creating a blank site

After finishing your login, create a blank site using this command:

netlify sites:create --name _<site name>_

4. Retrieving your Site ID and personal access token

To run continuous development remotely, you need both your site ID and your personal access token to help you.

Retrieve your site ID by:

Going into the site settings.
Copy the API ID value.

The next step would be to retrieve the personal access token.

Go to the user settings.

To get an access token, you have to make a new one:

Go to the Applications tab.
Click “New access token.”

Copy and save the access token shown on the next screen, and save it because you’ll need it later.

Set Repository Secrets

After we’ve retrieved the access tokens and site ID, we’ll save them inside the repository secret.

Note: Why do we need to use repository secrets? To prevent sensitive IDs or tokens from being pushed to the repository.

To create a secret:

Go to the repository settings.
Click Secrets on the left-side tab.
Click “New repository secret.”

On the “New secret” page input the secret name and value. When finished, click the “Add secret” button.

In its entirety, we’ve added about three secrets: the GitHub personal access token, the Netlify personal access token, and the Netlify site ID.

Retrieving the GitHub Access Token

Because we’re going to automate deployments using GitHub Actions, a personal access token would be required. You’d need to open your GitHub Developer Settings here.

After opening your developer settings page:

Open the personal access tokens page.
Generate a new token for GitHub Actions.

The next steps would be:

Input a name for your token.
Check the workflow to give access to GitHub Actions.
Scroll to the bottom of the page.
Click the “Generate token” button.

Copy the access token and save it somewhere because it’ll be used later on.

Creating the CI/CD Workflow

CI/CD using GitHub Actions is fairly simple. It requires us to make a YAML file. This YAML file is called a workflow in GitHub Actions because it defines the steps needed to form a CI/CD.

name: Flutter-CI
on:
  push:
    branches: [master]
  pull_request:
    branches: [master]
  workflow_dispatch:

To start our workflow, we must enable builds to start after push/pull requests to the master branch, assuming all deployments would be from the master.

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - uses: subosito/flutter-action@v1
      with:
        channel: beta
    - run: flutter config --enable-web
    - run: flutter build web

For the Flutter building process, I used an action made by subosito. You can check the Flutter Actions detail here. For Flutter web, we first have to initialize the configurations to enable web builds. Thus, we ran:

flutter config --enable-web

Then if you want to add tests to the workflow, you can by adding the command:

flutter test

Finally, build the app using:

flutter build web

The results of the build will be in the build/web folder.

    - name: Deploy to Netlify
      uses: nwtgck/actions-netlify@v1.1
      with:
        publish-dir: './build/web'
        production-branch: master
        github-token: $
        deploy-message: "Deploy from GitHub Actions"
        enable-pull-request-comment: false
        enable-commit-comment: true
        overwrites-pull-request-comment: true
      env:
        NETLIFY_AUTH_TOKEN: $
        NETLIFY_SITE_ID: $
      timeout-minutes: 1

After a successful build, deploy the files to Netlify manually. Here’s a snippet I used by nwtgck. I changed a few variables to be able to publish Flutter apps, but you can check Netlify Actions here.

In this last workflow, you’ll access the secrets we previously stored on our repository settings. The entire workflow can be copied from this gist below:

name: CI

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - uses: subosito/flutter-action@v1
      with:
        channel: beta
    - run: flutter config --enable-web
    - run: flutter build web

    - name: Deploy to Netlify
      uses: nwtgck/actions-netlify@v1.1
      with:
        publish-dir: './build/web'
        production-branch: master
        github-token: $
        deploy-message: "Deploy from GitHub Actions"
        enable-pull-request-comment: false
        enable-commit-comment: true
        overwrites-pull-request-comment: true
      env:
        NETLIFY_AUTH_TOKEN: $
        NETLIFY_SITE_ID: $
      timeout-minutes: 1

Your CI/CD workflow should be finished. Save the workflow inside .github/workflows, and try running it yourself! You can check the dummy site I deployed here.

Summary

We’ve successfully created a CI/CD pipeline for Flutter web using Github Actions. To summarize our steps:

Create a blank Netlify site.
Retrieve the personal access token from Netlify and the site ID.
Retrieve the personal access token from GitHub.
Set the secrets inside the repository settings.
Create a GitHub Action YAML file inside .github/workflows.

Voila! We’ve finished our tutorial. Now you have an open playbook to deploy your future Flutter web apps using GitHub Actions.

Automate Your Linux Deployment Using Azure DevOps

Agustinus Theodorus — Thu, 10 Dec 2020 12:49:28 +0000

Feel like you have been logging into your Linux servers too much lately? Good, this might be the right article for you. In teams, either large or small manual deployments can be tedious. But they are also predictable. Deployment steps don’t really change that often unless you have a breaking change or you are implementing a major feature.

So, why don’t you just automate it? You don’t need to do it yourself. Do important things like writing code and let a machine do the deployments for you.

If your team is blessed to use Azure DevOps here is a tutorial to finally automate the hell out of your deployments. You seldom have to log on to your Linux servers again.

In this tutorial, we will be making an automated pipeline to deploy .NET Core applications to a Centos 8 server. The app will be run as a service and we will serve those services through a reverse proxy using NGINX.

Installing Azure Agent on Linux

In Azure DevOps, we use an agent to interact with our builds in the pipeline. Installing agents are straightforward, just follow these steps:

1. Setting Up A Deployment Group in Azure DevOps

Deployment groups are the list of agents already installed on your servers. You would need to make a deployment group for each server.

First, open your Azure DevOps dashboard.

Next, open your Pipelines

Go to Deployment Groups , and click New.

Give your Linux VM an Alias, and the description. Then click Create.

You have created a deployment group, now to install this deployment groups agent on your Linux server:

Change the target from Windows to Linux.
Check the Use a personal access token checkbox.
Save the script on a notepad for the next step.

2. Installing the Agent on the Linux Server

To install the agent, run the script copied from the previous step in the home directory , make sure you run the script with a user that has sudo enabled.

After installation is finished run go into the azagent directory and check the installation by trying to run the agent:

cd azagent  
./run.sh

If the agent returns a Listening for Jobs message, that means the installation was successful. The next step is to make a service that can run the agent in the background.

To start to install the agent as a service, run:

sudo ./svc.sh install

This will install the service, and then run it in the background. To stop the service run:

sudo ./svc.sh stop

Otherwise, if we want to start an installed service, run:

sudo ./svc.sh start

Check if the service is running by opening the Deployment Groups tab in Azure DevOps. If it is Online then your agent installation is successful and it is available for jobs.

This short installation guide was based on an article by Microsoft.

Configure your Linux server for automation

Now, this would be the fun part. Microsoft already did all the heavy lifting with the boring installation things. Now it is our turn to automate things.

1. Make a script to automate NGINX configurations

To add new NGINX configurations we will create a shell script, add this add-nginx-conf.sh script on the home directory:

#!/bin/bash
conf_path="/etc/nginx/conf.d/$1.conf"

if [-f "$conf_path"]
then
    conf_text=`cat $conf_path`
    if [["$conf_text" == *"$2"*]] || [["$conf_text" == *"localhost:$3"*]]
    then
        echo "Proxy route or localhost port has been used, please manually reconfigure your Nginx configuration."
    else
        word="\n\n\tlocation \/$2\/ {\
\n\t\tproxy_pass http:\/\/localhost:$3\/;\
\n\t}"
        match="# Insert here"
        echo "$conf_text" | sed "s/$match/&$word/g" > "$conf_path"
    fi

    nginx -t
    systemctl reload nginx
else
    conf_text="server {
    listen 80;
    listen [::]:80;
    server_name $1;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    # Insert here

    location /$2/ {
        proxy_pass http://localhost:$3/;
    }

    error_page 404 /404.html;
        location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
        location = /50x.html {
    }
}"

    echo "$conf_text" > "$conf_path"

    chcon unconfined_u:object_r:httpd_config_t:s0 "$conf_path"
    chown root:root "$conf_path"

    nginx -t
    systemctl reload nginx
fi

This script will create a search for configuration files named using the associated DNS, it will create a new one if it was not found. Once found, the new configuration routes will be added there. Mind you, the configuration route in this script would be a basic proxy pass, you might want to add more configurations to the script if you want to use it for production.

The shell script accepts three parameters. The DNS, proxy route, and the port being used:

sudo ~/add-nginx-conf.sh <DNS> <proxy route> <app port>

Example:

sudo ~/add-nginx-conf.sh yourdomain.com enrichment_track 14321

In this example, the script will add configurations for the yourdomain.com domain, with a reverse proxy to port 14321 in the enrichment_track.

2. Make a script to automate system service configurations

To add new system service configurations we will create a shell script, add this make-service.sh script on the home directory:

#!/bin/bash
file_path=`pwd`
service_path="/etc/systemd/system/$1.service"
if [-f "$service_path"]
then
    echo "Service file already exists"
else
    touch "$service_path"
    service_contents="[Unit]
Description=.NET Web API for $1

[Service]
WorkingDirectory=$file_path/_$1/drop/s
ExecStart=/usr/bin/dotnet $file_path/_$1/drop/s/$2.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-example
User=<user>
Environment=ASPNETCORE_ENVIRONMENT=<server environment>
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target"
    echo "$service_contents" >> "$service_path"
    systemctl start $1.service
    systemctl enable $1.service
fi

Before you copy and paste the code, notice the <user> and <server environment> tags in the script. Please change it to your corresponding user and server environment beforehand. Server environments in this case would be either Development or Production.

The script will generate new systemd service files that would run .NET Core projects. To generate scripts for other types of applications you would want to change the given template.

The shell script accepts two parameters. The service name, and the project name used:

sudo ~/make-service.sh <service name> <project name>

Example:

sudo ~/make-service.sh CI-Build API-Project

In this example, the script will add a new system service file CI-Build.service, that runs a dll file named API-Project.dll.

3. Setup a user to run systemctl and Nginx commands without password prompts

For automation purposes, the user that you used to install your Azure Agent needs to be able to run systemctl and Nginx commands without a password prompt. To remove the password prompts on sudo run:

sudo visudo

We need to run all the commands in the script using sudo without having a password being prompted. So, we make exceptions for those commands, and the corresponding scripts we are going to use.

Then add this on the last line (change the <user> tag beforehand):

<user> ALL=(ALL) NOPASSWD:/usr/bin/systemctl, /usr/sbin/nginx, /usr/bin/chcon, /usr/bin/chown, /usr/bin/echo, /usr/bin/touch, /usr/bin/sed, /home/<user>/make-service.sh, /home/<user>/add-nginx-conf.sh

Exit and save the config file, then try running one of these commands using sudo. You should not be prompted for a password.

A full explanation on how to run a sudo command without a password can be seen here.

Prepare the Pipelines

Prepare the CI Pipeline

In this tutorial, we are going to use a .NET Core app as our example.

First, go to the Pipelines tab.
Click New Pipeline.

Use the classic editor.

Choose a repository and click Continue.

Apply the .NET Core template.

Search for “.NET Core”.
Then apply the template

Because we are deploying a very small example app, I didn’t prepare any tests so:

Click the Test task.
Remove the task.

Otherwise, if you are using tests, then don’t remove this task.

Finally, this is what you are left with. In the next step, we will implement Continuous Development in our solution.

Change the name of your CI pipeline.
Save the Pipeline.

Prepare the CD Pipeline

To add a new Continuous Development pipeline:

Go to the Releases tab.
Click the New.
Then click New release pipeline to create a new pipeline.

After clicking the New release pipeline button a pop-up will appear, then select Empty Job.

To connect to a CI pipeline:

Click Add a new artifact.
Choose the project that contains the CI pipeline.
Choose the CI pipeline.
Give an alias to your artifact.
When all is done click Add to finish the configuration.

Then for the Continuous Deployment pipeline:

Click the thunderbolt icon.
Then check the Enabled button.

After creating a stage, on stages , double click on tasks to go to the Tasks section.

In the tasks section, make a deployment group job.

Click the three dots to show options.
Add a deployment group job.

Choose the Linux deployment group we made on this step.

Add a task to the deployment job.

To add a new task click the + sign.
Then search for Download build artifacts. This task is to download artifacts from the CI pipeline to the Linux VM.
Finally, Add the task.

Next is to configure your Download Build Artifacts job. Follow these 6 steps.

Click the Download Build Artifacts task.
Choose to download artifacts by Specific Build.
Define your Azure DevOps project
Define your CI pipeline.
Check the When appropriate download artifacts from the triggering build checkbox to trigger a download only after the build is finished.
As for the download, type choose Specific files.

Then search for the Command line task:

Create a new task by clicking the + button.
Search for “command”.
Click Add to add a new task to the existing job.

Then in the command line, paste in the script you will be running:

Copy the appsettings.json file from the home directory to the build folder.
Generate system service configuration files and start if not exist using the make-service.sh script.
Restart the service for the .NET Core project.
Add NGINX configuration if not exist using the add-nginx-conf.sh script.

Notice in the command line, there are tags like $(Build.DefinitionName). This is one of Azure Pipeline’s pre-defined variables you can learn more about it here.

After you’re done with the configuration, save your Release pipeline:

Change the name of the Pipeline
Save the pipeline.

Testing the pipeline

To test the pipeline, go to the Pipelines section, open the pipeline you just created, and click Run Pipeline.

We run it from the CI pipeline because both CI and CD pipelines are already connected.

Summary

In this tutorial, you have learned how to automate CI/CD deployments using Azure DevOps and some shell scripts. We tested it out using a .NET Core project. The Linux server used was a Centos 8.

To recap what we have done:

Installed an Azure Agent on Linux.
Configured our Linux server for automation.
Prepared the CI/CD Pipelines.

You now have an open playbook to use when you want to automate deployments. Hope this tutorial was of help and have a nice day!

How To Choose Your First Techstack

Agustinus Theodorus — Wed, 18 Nov 2020 13:01:31 +0000

For all these years in the tech industry. I assure you that I have had my fair share of technology. A multitude of different frameworks aiming to achieve the same thing with their own different takes. Teams that prefer different tech stacks. It doesn’t matter what you learn but how fast can you adapt.

In this article, I might not give you exact answers to what you should choose. Because I believe that you should find what is comfortable for yourself. I would just explain what my ideas were when I chose my stack.

The Job Stack

When you first started working as a software engineer, you would realize that you can’t decide what tech stack your company would use, initially. You would need a lot more rep and power to be making those decisions.

So, there you are stuck with a legacy system using VB 6.0. Probably that shouldn’t be your choice. If you have ever used VB 6.0 damn, how programming has improved over the years. No, this is not an endorsement for VB 6.0.

In my company, we mainly use C# and PHP. I was mentored using C# and ASP.NET MVC when I was first starting, then continued to use PHP and CodeIgniter in my second year. So the choices were between these two.

I chose C#. Why? Well here comes the subjective part. PHP is not a language for me. It is too flexible and there are too many syntaxes that do the same thing. My experience was with PHP5, now it’s with PHP7 things have improved but I have already invested more time on C#.

The point here is that you can choose to deepen your skill in a modern language used by your current employer. It would be easier and you can suggest implementations of some cool stuff using your employer’s language of choice.

For example, recently when being tasked with making a multithreaded background service. Using C# and .NET Core really helped me craft a perfect solution for my employer.

The best part is not the solution, the best part would be the fact that anyone in your team can maintain your application. Collaboration would be easy because the language used is universally understood by engineers in your company.

The only downside would be the lack of freedom. You can’t force your will upon your employer, and if you try to master a different language, you end up learning 2 things at the same time. It depends on you personally but I would prefer to avoid that.

The Swiss Army Stack

Ooh, swiss army stack! That sounds cool, doesn’t it?

This particular stack consists of mainly one language with multiple different frameworks for different situations. A good example here would be the Javascript/NodeJS ecosystem.

Javascript

Who here doesn’t know NodeJS? Look it up.

Using a front-end framework like React, Vue, or Angular has been the norm. They all use Javascript/Typescript. So why bother learning a different language other than Javascript? Just use Express for the backend and your all set. Fullstack Javascript here we go.

Hey, do you know Javascript can do AI too? It can, there is a library called Tensorflow.js. Now don’t tell me that isn’t amazing?!

To be clear, I am not advocating for Javascript. It is just one of those languages that have a lot of functionality. Another example would be Python, and probably Dart.

Python

I don’t know about you, but Python is still looking hot nowadays. It still hasn’t lost it’s easy to use appeal. You can make a ton of things with Python, web applications, APIs, AI applications, background services, etc.

As far as I know, the Javascript ecosystem’s AI libraries aren’t as mature as Python. Python is the main go-to language for AI. Youtube AI programming tutorials usually are done using Python. Some exceptions are using Javascript but my argument still stands.

But Python does suck at frontend programming. Javascript beat Python in GUI building by a longshot.

Dart

Honestly, this should be an honorable mention. But because the environment is quite interesting and has some potential, I thought I would bring it to light.

So, the main powerhouse behind Dart is Google’s Flutter. The prospect of a multiplatform frontend framework for Desktop, Mobile, and Web is very promising, to say the least.

Sure, Javascript has a multiplatform framework. There’s React Native. But it’s only for React. So, mobile and web. How about Electron.js? Sure it would work for Desktop. But Flutter alone compasses all three.

Backend though. It isn’t as promising. The only backend framework I know that uses Dart is probably Aqueduct. Though to be honest, I haven’t had time to research that. So I don’t know if it is already production-ready.

Out of the three languages, I would say Dart is the least mature tech stack. An immature tech stack can bring opportunities for new developers to contribute to the open-source ecosystem, but the downside would be very unstable ecosystem wise.

The Mature Stack

Mature by what definition? These tech stacks have been around for a while. Has been battle-tested and many applications are using them.

For example, in the case of web frameworks, a mature framework would be C#’s ASP.NET, Java’s Spring, Python’s Django, PHP’s CodeIgniter, Symfony, and Ruby on Rails. These are some of the oldest tech stacks, developed between 2002–2006. Many corporate applications use these frameworks.

Being knowledgeable about these tech stacks are only good if you want to join large corporations. New startups have a very different tech stack, not because these frameworks are bad. But because there exist more production-ready options today.

I personally have tried 3 of the previously mentioned frameworks. ASP.NET, Django, and Ruby on Rails. My favorite was Ruby on Rails. Django was always too complicated for me, I prefer to use Flask for Python web development. It’s hard to host ASP.NET applications on Linux so I also passed on that.

So, which should I choose?

Now, this is where it gets opinionated.

Take this with a grain of salt, try it out yourself. There are many more technologies available than what I have written here.

If you dislike your job stack, well you can use it for professional purposes only, and try to find another job with a tech stack you like. Nothing you can do about it.

My simple guide would be to master one object-oriented language and one scripting language, and if you’re lucky both of them would be multiplatform.

I on the other hand love C# and .NET Core, so it has not been a problem for me. I prefer it over Java because C# libraries are helpful and are already all too familiar to me. .NET Core is also multiplatform, and unlike previous ASP.NET releases, it runs seamlessly on Linux.

My scripting language of choice would be Python. Writing in Python has been so wonderfully easy. I am very comfortable with the amount of flexibility the language gives me. The libraries are also mature and because I have an obsession with AI, implementing an AI model in a web application is seamless.

Seeing my choices you might be wondering. “Hmm, so C# and Python. Aren’t both of them backend languages?”, and you are right. Well, apart from C# Blazor. But I don’t use Blazor that much so I’ll turn a blind eye to that.

For front-end purposes, I use Javascript frameworks. This limits my capabilities to pure web applications because Javascript frameworks are mostly well known for its front-end web frameworks. But another benefit of learning Javascript is that it is an in-demand skill. Javascript can have production-ready environments for both front-end and back-end most companies take advantage of that.

Furthermore, Javascript has another benefit of being a free tech stack. Here’s what I mean. There is a service called Netlify. Netlify hosts JAM Stack applications, and if you have reasonably small traffic, Netlify covers the costs for free. JAM stands for Javascript, APIs, Markup. Add to that Netlify also has a service called Netlify Functions.

Netlify Functions utilize serverless technologies to make simple APIs using Javascript using AWS Lambda as their base. You are only charged after 125k~ requests or so.

My next statement might sound controversial, but in my opinion, adding Javascript to your knowledge repository can help you get a job. It is very popular and very flexible. Being multiplatform it is cost-effective and the choice of many modern startups. Some corporations are also planning to migrate to Javascript environments.

Conclusion

So? Found your calling yet? Don’t rush. It’s fine. Do what you think is right. If you want to learn them all, be my guest. I am already at a stage where I want to master concepts rather than frameworks so I can say I understand how it feels. Be slow but sure, you won’t master it all overnight.

“The master has failed more times than the beginner has even tried.” — Stephen McCranie

Don’t be afraid to try. Failure is only a step. Thank you and have a nice day!

How To Host Flutter Web In Linux Using Nginx

Agustinus Theodorus — Sun, 08 Nov 2020 22:02:42 +0000

Thinking of making a web app? I recommend you try Flutter. Flutter’s web capabilities are still in beta but it’s quite promising, to say the least. I have experienced first hand how quick it is to build UIs using Flutter and I think it could soon be a competitive alternative to the Javascript ecosystem such as React, Vue, and Angular.

So to help out the future Flutter community members, a tutorial on how to host your Flutter web app on a DIY private server would help. As a healthy alternative to Firebase.

What would you need?

Umm, first of all, a private server.

With serverless capabilities nowadays it is no wonder that people prefer Firebase, it’s free and it’s painless. Obvious choice.

But what if we want to go independent? Away from the norms? Well, you have to learn it all yourself. Because we are using Nginx, then the server must be a Linux server, not a Windows server.

Assuming you use a Debian/Ubuntu-based Linux distro. Here’s a starter script to help you get started.

sudo apt update  
sudo apt install nginx

There, I just saved you some googling time. If you want an in-depth guide on Nginx, I suggest you read this post by Digital Ocean.

Do we need to install the Flutter SDK on our server?

Umm, yes, and no.

Let me elaborate. It is possible to install the SDK, but why do you need exactly? Installing the SDK helps you to test quick changes to the code on the server to try to fix a few production-related bugs like a cowboy!

I won’t do it though because SDKs consumes a lot of memory and requires a lot of RAM to be compiled. Your private server might not have enough RAM to process it. Believe me, I’ve tried. My VPS only had around 400MB of RAM enough to run a small app but not enough to compile the SDK. So I didn’t install it.

So this just leaves one option either you use CI/CD to deploy your Flutter app to your VPS or just use plain old git. By using Git I mean by pushing your builds to the repository. This might not be a best practice for some teams as the entire software world almost unilaterally agree on using CI/CD, but hey — a cowboy’s gotta do what a cowboy’s gotta do.

I am not going into how much of a best practice this tutorial is going to be rather how simple and understandable it is. So let me just leave this choice to you.

Do I need a domain?

Do you need a domain? No. It is not required because we are learning how to host a Flutter web app using Nginx using a domain or not is not of this tutorial’s concern.

Build your app

After your app has been tested, run the Flutter build command.

flutter build web

That should generate a build folder within your project structure. Within the build folder, there is another folder named web which contains the essential files to be used for hosting.

The web directory should contain a file named index.html.

Configure Nginx

Here come’s the fun part. Now copy that web directory to your VPS in any fashion you would want. Then make sure you move the build files to /var/www/html.

Let’s say your application name is todos so a good folder naming convention would be /var/www/html/todos. Inside the todos directory is the build files, index.html, etc. If you’re not familiar with Linux commands this should help, assuming that your build files are in your home directory.

sudo mv web /var/www/html/todos

Next, you need to go to the Nginx directory on your server more precisely /etc/nginx/sites-enabled. There should be a file named default. Open it using a vim/nano text editor of your choice and change the root directory on the configuration file to /var/www/html/todos.

No Domain Setup

# Default server configuration
server {
       listen 80 default_server;
       listen [::]:80 default_server;

       root /var/www/html/todos;
       index index.html index.htm;

       server_name _;

       location / {
              try_files $uri $uri/ =404;
       }
}

Here is an example. The original file should be filled with comments, but I left those comments out in the gist. After changing your config files, check your Nginx config using this command:

sudo nginx -t

If all is well, then restart the Nginx service:

sudo systemctl reload nginx

This should restart your Nginx server and get the updated config file. When all is done open up your VPS IP Address from the browser. Your Flutter app should already be up.

I prefer people access my app by domain so I’ll include how to set up the app using a domain here too.

Domain Setup

When you don’t want to use a domain, changing the default file should be fine (even though some people prefer to leave the default as-is and create a new one).

But when you want to use a domain, make sure you make a new configuration file. The file should have a .conf extension.

# Default server configuration
server {
       listen 80;
       root /var/www/html/yourdomain.com;
       index index.html index.htm;

       server_name yourdomain.com www.yourdomain.com;

       location / {
              try_files $uri $uri/ =404;
       }
}

I have attached the corresponding gist. The setup should be similar to the previous one with a difference in the server_name. Then before you open your app from the browser, run:

sudo nginx -t

If configuration health checks pass, reload the Nginx service.

sudo systemctl reload nginx

After restarting Nginx, try to open your domain from your browser. It should be done by then.

Further Note

Don’t forget to update domain nameservers

When you want to use a domain, please make sure you point your domain nameservers to your VPS. You are required to do this before any further configuration is to be done.

Install an SSL certificate using Certbot

There’s a technology called Let’s Encrypt. It gives you free SSL certificates to be used for your apps, securing your app, and adding HTTPS to your domain. Install Certbot for Nginx using this command:

sudo apt install python-certbot-nginx

Then, install SSL certificates on your domains:

sudo certbot --nginx -d your\_domain -d www.your\_domain

Summary

In this tutorial, you have learned how to serve a Flutter application using Nginx. You now have an open playbook to use when you want to deploy Flutter web applications using Nginx on your own server. Hope this tutorial was of help and have a nice day!

How To Make Scalable APIs Using Flask and FaunaDB

Agustinus Theodorus — Tue, 27 Oct 2020 23:50:13 +0000

With the rise of serverless technology, making web services only gets easier. Serverless apps change the old monolithic architecture of apps and promote more of a microservice solution to technical problems.

With the advantage of autoscaling, and multi-region deployments it is no wonder that serverless apps are making a quick rise in recent years. The cost of serverless has also redefined how we make software as it is now on a per request basis rather than a time-based service.

Even better, serverless also enables small services to be free altogether. Only being needed to be paid after a million requests or so. An example would be Azure Function’s consumption plan.

What does Serverless have to do with this tutorial?

The main reason serverless is being mentioned here is because FaunaDB is a NoSQL database that is made for serverless in mind. The pricing on this database is request based, precisely what serverless apps need.

Using a service like FaunaDB can help cut costs so much that the hosting capabilities of the app would be virtually free. Excluding the development costs of course. Thus, using a monthly billed database for serverless apps kind of kills the point.

A free stack example would be a combination of Netlify, Netlify Functions, and FaunaDB. Though it would only be ‘free’ for a certain amount of requests. Unless you are making an app that gets thousands of users on day zero of deployment I don’t think it would be much of a problem.

In my opinion, using a monthly billed database for serverless apps kind of kills the point

Flask on the other hand is a microframework written in Python. It is a minimalistic framework with no database abstraction layers, form validation, or any other particular functions provided by other frameworks.

Flask is by large serverless compatible. You can make a serverless Flask app using AWS Lambda. Here is an official guide to Flask serverless from serverless.com.

Getting Started

Setting up Python and Pip

First of all, install Python and Pip. I’m not going to list all the possible ways of installing it, for Windows users you can get the installer here. As for Linux users if you are using a Debian/Ubuntu-based distro open your command prompt and install python and pip like this:

sudo apt update  
sudo apt install python3 python3-pip

To check if the installation is correct try executing these commands:

python --version  
pip --version

The version numbers would then show for the corresponding commands.

Installing dependencies

After the environment setup is complete, the next step would be to install Flask itself. The installation process is simple just enter:

pip install Flask

Then, install the python driver for FaunaDB:

pip install faunadb

Voila! You’re all set!

Making a To-Do List App

Now we are going to make an example app with the mother of all app ideas, the to-do list app.

To-Do List Template

For this example, because we will be focusing mainly on how to make the API we will be using the W3School template for the to-do list app frontend.

Basic Project Structure

Our project would be an implementation of a helper pattern. A simple outline of our project would be like so:

\-
 |--app.py   
 |  
 |--services  
    |--todo_service.py  
 |--helpers  
    |--todo_helper.py  
 |--entities  
    |--faunadb_entity.py

FaunaDB Indexes

Wait, what are indexes?

Indexes are how you make ‘where’ statements in FaunaDB. It allows you to get specific documents based on the field values.

To create a new Index, just go to the Indexes section on your database and click New Index.

When creating an Index, choose the collection you would want to interact with. Then define the field name you want to search by. Lastly, define your index name make sure it is unique and readable.

For example, let’s make an index where we can get all the data in an existing collection.

Oh, what about an index to get todos by the user’s email? Easy.

If you want to make the terms unique, check the Unique checkbox to add a constraint.

To add constraints to a certain collection you need to create indexes with terms that contain unique fields.

To help you understand better, here is an official article from Fauna to help you understand indexes.

Let’s Make The API

Make the Flask startup file

First, write a python file that would run Flask.

from flask import Flask

app = Flask( __name__ )

if __name__ == " __main__":
    app.run(host='0.0.0.0')

Write the FaunaDB entity script

Next, before we start writing our services and helpers we must first define an entity file to connect to FaunaDB.

import os
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient

def get(index, data):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        res = serverClient.query(q.get(q.match(q.index(index), data)))
        res["data"]["ref_id"] = res["ref"].id()
        return res["data"]
    except Exception as ex:
        raise ex

This is used to get a FaunaDB document by Index. The get function does not return multiple documents and is only able to return a single document at a time.

To get multiple documents we need to use a map function to return multiple data by a certain index.

def get_multiple(index, data=None):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        res_arr = []
        if data is None:
            res = serverClient.query(   
                q.map_(
                    q.lambda_("data", q.get(q.var("data"))), 
                    q.paginate(q.match(q.index(index)))
                )
            )
            res_arr.extend(res["data"])
        elif isinstance(data, list):
            for x in data:
                res = serverClient.query(   
                    q.map_(
                        q.lambda_("data", q.get(q.var("data"))), 
                        q.paginate(q.match(q.index(index), q.casefold(x)))
                    )
                )
                res_arr.extend(res["data"])
        else:
            res = serverClient.query(   
                q.map_(
                    q.lambda_("data", q.get(q.var("data"))), 
                    q.paginate(q.match(q.index(index), q.casefold(data)))
                )
            )
            res_arr.extend(res["data"])

        arr = []
        for x in res_arr:
            x["data"]["ref_id"] = x["ref"].id()
            arr.append(x["data"])
        return arr
    except Exception as ex:
        raise ex

The lambda function will pass the data needed in the Index while paginate will search for the specific documents in the collection, then the map function will return all matching documents as a list.

def get_by_ref_id(collection, id):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        res = serverClient.query(q.get(q.ref(q.collection(collection), id)))
        res["data"]["ref_id"] = res["ref"].id()
        return res["data"]
    except Exception as ex:
        raise ex

Get document by reference Id is the only function that does not use an Index rather would utilize the document’s reference Id.

The code for creating, updating, and deleting documents would be similar. Because FaunaDB is a NoSQL database the data structure doesn’t matter as long as it is passed as a dictionary. Updating and deleting documents would also need an extra reference Id parameter, similar to the Get document by reference Id function.

def create(collection, data):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        res = serverClient.query(q.create(q.collection(collection), {"data": data}))
        res["data"]["ref_id"] = res["ref"].id()
        return res["data"]
    except Exception as ex:
        raise ex

def update(collection, id, data):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        res = serverClient.query(q.update(q.ref(q.collection(collection), id), {"data": data}))
        res["data"]["ref_id"] = res["ref"].id()
        return res["data"]
    except Exception as ex:
        raise ex

def delete(collection, id):
    try:
        serverClient = FaunaClient(secret=os.environ.get("FAUNA_SERVER_SECRET"))
        serverClient.query(q.delete(q.ref(q.collection(collection), id)))
        return True
    except Exception as ex:
        raise ex

Make the To-Do helper

After writing the FaunaDB entity script, write the helper functions for the collection. The helper functions need to be small precise functions that do exactly one thing.

from entities.faunadb_entity import get, get_multiple, get_by_ref_id, create, update, delete

def get_all_todos():
    try:
        return get_multiple('all_todos')
    except Exception as ex:
        raise ex

def get_todo_by_ref_id(id):
    try:
        return get_by_ref_id('todo', id)
    except Exception as ex:
        raise ex

def create_todo(data):
    try:
        return create('todo', data)
    except Exception as ex:
        raise ex

def update_todo(id, data):
    try:
        return update('todo', id, data)
    except Exception as ex:
        raise ex

def delete_todo(id):
    try:
        return delete('todo', id)
    except Exception as ex:
        raise ex

Make the To-Do service

When all the helpers are ready, write the service file to be used as endpoints. All the requests are parsed at the service level, thus the helper level will only receive processed data.

from flask import request, jsonify
from helpers import todo_helper

def get_all_todos():
    try:
        print(todo_helper.get_all_todos())
        return jsonify(todo_helper.get_all_todos())
    except Exception as ex:
        raise ex

def get_todo_by_ref_id(id):
    try:
        return jsonify(todo_helper.get_todo_by_ref_id(id))
    except Exception as ex:
        raise ex

def create_todo():
    try:
        req_data = request.get_json()
        return jsonify(todo_helper.create_todo(req_data))
    except Exception as ex:
        raise ex

def update_todo(id):
    try:
        req_data = request.get_json()
        return jsonify(todo_helper.update_todo(id, req_data["data"]))
    except Exception as ex:
        raise ex

def delete_todo(id):
    try:
        return jsonify(todo_helper.delete_todo(id))
    except Exception as ex:
        raise ex

Attach the routes to the service endpoints

Finally, when the endpoints are set, add the endpoints to the app.py

from services.todo_service import get_all_todos, get_todo_by_ref_id, create_todo, update_todo, delete_todo
from flask import Flask

app = Flask( __name__ )
app.add_url_rule('/api/todos', methods=['GET'], view_func=get_all_todos)
app.add_url_rule('/api/todos', methods=['POST'], view_func=create_todo)
app.add_url_rule('/api/todos/<string:id>', methods=['GET'], view_func=get_todo_by_ref_id)
app.add_url_rule('/api/todos/<string:id>', methods=['PUT'], view_func=update_todo)
app.add_url_rule('/api/todos/<string:id>', methods=['DELETE'], view_func=delete_todo)

if __name__ == " __main__":
    app.run(host='0.0.0.0')

You’re done! Don’t forget to test the APIs with Postman before deployment.

Summary

TL;DR You can check out my Github repository for the project and try to run it yourself.

Boilerplate code for Flask and FaunaDB project

In this tutorial, you have learned to make an API using Flask and FaunaDB.

To recap we have made:

API endpoints using Flask.
Indexes in FaunaDB.
A simple entity helper for FaunaDB.
A readable boilerplate for future API projects.

You now have a quick boilerplate setup to use when you want to make a quick app in a matter of hours. Future plans include adding a Swagger implementation to the existing boilerplate.

Hope this is a great start for you, have a nice day!

How To Deploy Your .NET Core App on an IIS Server

Agustinus Theodorus — Tue, 20 Oct 2020 13:51:54 +0000

When you work in an enterprise environment you can’t choose where you would want to publish your application, especially if you enter a very established company. There would be times that you have to publish in a Linux environment, but in this case publishing in a Windows environment.

Configure your .NET Core project

When trying to deploy on an IIS Server, make sure you already configure your Startup.cs and Program.cs accordingly. On the Startup.cs you should add this config:

On the Program.cs add this config:

Configure your IIS Server

Downloading the required packages

Install the required packages before configuration.

Downloading the dotnet SDK

Deployments only need runtime, but if you want to have a more flexible environment that allows you to build and publish dll files rather than only running it you would want to install the latest dotnet SDK, here.

Install the Azure Artifacts Credential Provider

Next, install the Azure Artifacts Credential Provider, full instructions can be seen here.

Azure Artifacts Credential Provider Manual Installation Guide

Find the latest release here, and download the .zip package.

After downloading the zip archive, copy the plugins folder to %USERPROFILE%/.nuget

Set your environment variables, open User Variables and create a new entry.

Set the variable name to NUGET_PLUGIN_PATHS , and because in this case, we are going to be using the dotnet credential provider, so set the value to

%USERPROFILE%.nuget\plugins\netcore\CredentialProvider.Microsoft\CredentialProvider.Microsoft.dll

Then finish the setup by clicking OK on the Environment Variables dialog.

Publish your .NET Core application

Pull the project from DevOps

Get into the directory where you want to put the application.

Get inside the newly formed folder and run the dotnet publish command. Further info regarding the commands can be seen here.

If an authorization prompt to https://microsoft.com/devicelogin pops up, login using the Azure DevOps account and enter the code shown in the window.

Otherwise, it should show a successful build like so:

In this case, D:\deploy\api.test\bin\Release\netcoreapp3.1\publish is the physical path .

This will be the path used when configuring your app on an IIS application.

Run your .NET Core on IIS

Add the application pool

Right-click on the Application Pools option.

Choose the Add Application Pool option

Name your application pool and set the .NET CLR version to No Managed Code.

Then click OK.

Add the IIS website (Optional)

This configuration is optional as you can use a pre-existing site.

Right-click on the Site option

Click Add Website

Set the Site name and the physical path to the .NET Core build.

Click the Connect as… button, to connect as a specific user. Set your user credentials and click OK

Click Test Settings and it should show a pop up like this

Then on the Add Website dialog click OK to finish the setup.

Add the Application on the IIS website

On the site’s homepage, click on the View Applications button.

Click on the Add Application action

Set your alias, this will be the path on the Url. Then, set the physical path to the .NET Core build.

Next, select the application pool you previously made, then click OK

Click the Connect as… button. Set your user credentials and click OK

Click Test Settings and it should show a pop up like this

Then on the Add Application dialog click OK to finish the setup.

When all steps are done, your application should be running. Test this by opening a browser and put localhost/*your application alias* in the search bar.

Summary

In this tutorial, you have learned how to serve a .NET Core application using IIS.

To recap what we have done:

We have configured our .NET Core web app before deploying it on IIS.
We have installed the prerequisites for the IIS server.
We installed the required dotnet SDKs and the corresponding Azure authentication providers.
We have configured IIS to deploy our .NET Core app.

You now have an open playbook to use when you want to deploy dotnet applications on IIS. Hope this tutorial was of help and have a nice day!

4 Key Habits I Learned as a Software Engineer

Agustinus Theodorus — Mon, 12 Oct 2020 16:15:31 +0000

I am almost 3 years into software engineering. Honestly, I don’t think I am that good at it yet (I don’t know if I’ll ever be). But there are times when I wished that I knew somethings sooner than later. I thought it would be fun for me to reflect on those subjects and try to convey them to you as best as I can in this article. So here are the 4 key habits I learned as a software engineer.

1. Write Clean Code (Obviously!)

Bear with me here.

So I haven’t always been the cleanest coder in the team. Through my struggles, I always find it annoying that people don’t understand what I wrote. Heck, I am annoyed that I can’t understand what I wrote a month ago.

I thought, “Hey, why don’t I try to write cleaner?”. Well, sometimes cleaner code doesn’t always mean someone else will understand what the code means at first glance. Because there are other factors at play like the business process, etc. But it helps — I guess.

Don’t Repeat Yourself (DRY)

Let me tell you, no one annoys me more than myself. I honestly can’t explain how frustrated I am when I read old code that has multiple copies.

Trying to understand multiple copies of the same lines of code at different points in the documentation is really confusing.

So ever since I realized that I tried to write functions for code that I would be reusing often. Boy did that save a lot of headaches.

If you don’t do that you might have to change multiple documents that literally have the same line of code just to let’s say — add a new condition to an if-else statement. Take it from me, sometimes you can forget and bugs will happen. So please, write code you going to reuse in a function.

Speaking of functions…

Code Purposeful Functions

What I meant by purposeful is that you have to write functions that have one exact purpose. For example, I want to hash passwords so I would obviously write a function specifically to hash passwords.

This will add even more readability to your code and it will save you a lot of headaches when you need to say — change the hashing algorithms or whatever.

But don’t go too overboard, if you feel that you don’t need to write a function for that .ToString() method in C# than don’t. It’s already readable. Don’t overdo it.

2. Learn Design Patterns

Like writing clean code wasn’t enough! Well, to be frank, it isn’t. I have tried to maintain and develop a lot of software in the 3 years I have been a software engineer, and sometimes I would say the default design pattern doesn’t do me any good.

That’s why sometimes micro web frameworks like Flask are my favorites. I can go full creative in how I want my project to be, either by using repository patterns or otherwise.

Find the best fit for you, try to catch up using materials here.

3. Automate Tasks

If possible, you should automate everything. Automation might be the best thing I have ever done in my entire career. One time I wrote an application to write APIs for me, so I wouldn’t have to write code anymore.

Well to be fair, it was templated so I still have to code if the app isn’t a simple CRUD application, but it was a good start. This “code generator” coincides with the second point of learning design patterns. I would not have been able to make it if I didn’t implement a design pattern that was comfortable for me.

Another idea would be if your office has a ticketing system of some kind automating those to be added to your Agile boards might be a good idea. Well, it depends, but it is possible.

Other things you might want to automate probably would be menial tasks such as server monitoring and app deployments.

4. Be as Passionate About Writing as Coding

Let me explain, probably your job as a software engineer does not always involve code. Sometimes it will involve writing.

Maybe some companies have KPIs for writing on their engineering blog on Medium. But usually, the writing you would be doing involves documentation.

It is kind of related to coding but rather than writing code, you are writing about your code. In my personal experience, I would try to write the best documentation I can in the limited amount of time I would give myself. It helped tremendously when I had to handover projects to other teams.

For me, I write good documentation for myself, because I don’t want to be bothered by other people.

Good documentation means fewer people asking for your help to understand your code. Which means more time for you.

Keep that in mind the next time your boss asks you to document your code.

Conclusion

TL;DR Write clean code, try to implement the Don’t Repeat Yourself (DRY) mindset to your code. Write purposeful functions that are easy to read. Learn design patterns, find a pattern that you personally like. Also if possible try to automate your tasks. Finally, never be a lazy documentation writer. It can save you more time than you think.

In the end, we all have our own variety of lessons learned. These 4 are just mine. I am writing this not to persuade you rather share with you my personal opinions. Anyway, I hope you have a nice day!

4 Things I Learned About The Software Engineering Culture

Agustinus Theodorus — Fri, 11 Sep 2020 11:20:37 +0000

When I started my first job as a software engineer I would have never realized how narrow my world view regarding tech was. In my mind, the world of software is as large a pool when it is an ocean.

1. Everyone Starts Confused

It is commonly said that most software engineers don’t know what exactly their profession would be in the tech world. It becomes more complicated today as more branches of software engineering emerge. The fast emergence of AI has opened many branches of software engineering roles such as Data Scientist, Machine Learning Engineer, and Deep Learning Engineer. Each role is different and needs exceptional skills in their own right.

This coincides with previously available roles like Database Administrators, System Administrators, Networking Engineer. Heck, even Software Engineers have sub-roles like Frontend Engineer and Backend Engineers now because of how complicated software is nowadays. I don’t think I have even touched on the security roles yet.

I honestly entered the tech world thinking I would end up as a Frontend Engineer. Today I am mainly focusing on backend services, system administration, and machine learning. If you’ve ever touched any one of these skills you would understand how different these 4 roles are.

I ended up learning everything I can. Though I am currently focusing more on machine learning than any other field. I find making computers do menial and repetitive jobs amusing.

2. Your Not In A Pool — Your In An Ocean

As you might have already noticed, there are many flavors to software engineering. Some roles might be more enticing than others. But it doesn’t make those other roles less important.

Every role in the software department needs to work together. Either you’re the networking engineer to the backend engineer. As you progress forward you would respect your colleagues for their contribution. Because in the end, they know things that you may not know, as well as you knowing things they do not know. Respect should be mutual.

Mentorship should not always be a relation between seniors to juniors, rather peers from different backgrounds.

In my opinion, you should always take every opportunity for a sharing session with your peers. You would never know what you would get out of it.

3. Software Engineering Is A Sharing Culture

Ever heard of the term open-source? Open-source software is software projects that allow for contributions from anyone. Contributions to an open-source project come in many forms. If you are a highly skilled engineer that has an interest in the project, you may contribute your time to help develop the project altogether. Otherwise, you can usually support the project maintainers by donating money to them directly.

In this culture sharing is the norm. We contribute to the field and everyone in it while being open and transparent about it.

Even though software engineering has an open culture it doesn’t mean plagiarism would be left unchecked, don’t ever steal someone else’s source code and claim it as your own.

Originality is always appreciated!

4. Mentorship Is Essential

My first years as a software engineer began with mentorship. I entered a trainee program to make apps that solve real-world problems while learning.

It was one of the most formative years of my life. I have always wondered how my life would be like after my trainee years have passed. It has been 2 years since then, I can say it helped me through a lot.

Just as in any field, mentorship gives you a boost in learning. It helps you skim through the less important skills and gives you an insight into what skills you need to improve to reach your end goal.

It is completely forgivable if you don’t know what role you would be focusing on specifically. Precisely why every new software engineer should go through some sort of mentorship with more senior software engineers, to help them go learn faster.

For example, a backend engineer does not necessarily need to learn artificial intelligence. Though it might be a useful skill, there are more important things at hand.

5. Sharing Helps You Learn Too

Some people might not know this, but sharing helps you learn. When you are sharing what you know with other people, you get the chance to review your knowledge and probably patch holes in your knowledge that previously was unbeknownst to you.

Sharing also gives you the opportunity of being questioned by inquiring minds. As the saying goes, “Two heads are better than one”.

If you encounter a question that you have never thought about, you gain a plus there. A new insight.

When given the responsibility of sharing your knowledge, of course, you want to perform your best. You should be aware of the big responsibility of teaching. You wouldn’t want to disappoint. Given, it would improve your sense of responsibility to your own words.

Conclusion

So you think you are ready for the tech world? Don’t ever be afraid to ask for help. It is completely normal to not know about somethings in this field. You don’t have to be the know-it-all.

Be humble! It may be one of the most important traits you would ever need. If you know something your desk neighbor doesn’t it wouldn’t hurt to share a bit. Being a mentor can get you further than you would ever expect.

Thoughts About Being A Software Project Manager

Agustinus Theodorus — Fri, 26 Jun 2020 20:48:29 +0000

A few months ago I had an initiative that I have been wanting to realize. In the company that I have been working in, there seems to be a lack of documentation for teaching and no media for knowledge sharing between teams. I thought that there has to be one, for the better of us all.

Background

The Initiative

So I approached HR and proposed this project. To help people learn. Since I work on a university campus, I thought it might be a good idea to have the learning management system (or LMS for short) be available to the students there as well.

Well, that was the initial plan. As all software engineer knows, when it came up to requirement gathering the requirements were not really exactly what I wanted. It was less of an LMS and more of an HR information system.

Well, I didn’t mind. The LMS part of the system is still there, and I think that’s good enough as a start.

So a month in, the requirements were accepted by the user. Resources have also been allocated for my project.

Initially, I had a team of 3 people. It was me and two other guys. They bailed after knowing the project was going to use a new tech-stack they have never used before.

”Well…”, I thought, “It’s back to square one”. Luckily for me a year prior I was one of the interviewers for some of the new trainees.

Gathering the crew

It was surely a stroke of luck that my relationship with the trainees was on good terms.

I met one of them a year ago when I was active as an activist at my Uni, and I interviewed the other one. So, I figured they would like to have an opportunity.

When it came the time to ask. I breathed a sigh of relief after they said that they were interested.

A third person joined after he heard about the project from his friend, interestingly enough.

I orchestrated the first meeting between the four of us. At the beginning of the meeting, I said that it will be an opportunity for them to learn new skills. Since I was going for a relatively modern tech-stack (for the year 2020). A Vue frontend and a .NET Core backend.

Just like that — the project was on.

Happily ever after — sort of…

The three trainees’ main responsibilities would be code, my responsibilities were more — many more.

Sure I tried to do project management by the book. I used a virtual board on Azure DevOps to list all the requirements, and I also arranged weekly meetings to calculate the project’s velocity.

I thought that would be enough — boy was I wrong.

First of all, I may have relied on the trainees a little bit too much and I needed to back them up more than I thought. I am not blaming them, it was my fault for not considering their skills thoroughly.

Second, I think my requirement gathering skills have a lot of room to improve. I analyzed a few features wrong and came up with very conflicting results — I had to clean this up in the end, it was my fault after all.

So here I am being a project manager, guiding the trainees, fixing all my requirements, talking to the techies in my company making sure everything was safe, secure, and best practice. Boy… that was an experience.

I honestly felt bad for the people I led because they might be more confused than I am. Though I always try my best to help them solve their problems. I did promise them that they would learn something and I really meant it.

What I’ve learned

Mistakes made

I have been a programmer for 3 years now and I think it’s about time I led my own team. I won’t lie that it was neither easy or relaxing. It was a stressful experience with many mistakes made along the way.

I was lucky that my team was made out of trainees eager to learn, thus they still continued on through my less than average project management skills.

It was a learner though.

After being a project manager I now can grasp what needs to be done by a project lead, or team lead. This is why those roles have less programming and require more time to literally manage the ongoing project.

Good project management can be done if the person in charge is focused on doing so.

I was a little to stretched thin at that moment. I needed to help trainees solve problems that they couldn’t while considering the project and safety of the entire codebase.

It was a real hassle.

I don’t want to say that I was busy, rather that I could not focus on what I should have done, managing the project.

System analyzing wise, I can confidently say that — I suck at it, still a long way to go.

I didn’t have a good design doc to look up, only a few notes on how it would be made. So I have to read what I wanted to do, probably a user diagram would be helpful or an application flow diagram.

I know that this is software project 101 but I am honestly saying that I missed that. I really blew it.

Now look at this diagram, can you imagine the number of roles needed when we want to create this application? It is written on the diagram and it is as clear as day.

Now imagine having no diagram and trying to understand this system by writing. Better yet, try to translate this diagram into a paragraph. Good luck! I didn’t make this and it made me forget what I wanted to do indefinitely. A big lesson learned.

Feature-wise there should be a clear application flow to explain how the system works, how the users register, and so on.

Sadly I also didn’t make it. It contributed to the disarray of the trainees under my wing. It showed how a project with good intentions became a complicated one at best. “If only”, I said to my self, “I have done this”.

I used waterfall as the software development lifecycle because the requirements were constant and the user wasn’t much of a hassle.

This further amplified my mistakes because — waterfall absolutely needs these kinds of diagrams.

The requirements were constant and might as well made diagrams from the beginning to help understand the system beforehand.

If I were to use agile however my huge mishap might be forgiven a little bit. Because if you were to use agile even though an initial design doc is very important, the requirements are fluid thus you might have no time to keep making a design doc and must continue on programming to finish the project before a deadline.

I am not saying that a design doc is not important, not by a long shot. I am just trying to imply that the requirements are fluid and you might be forgiven for making a design doc that is slightly different from the end product.

A Realization

I realized why it is important that project management roles shouldn’t be too caught up in programming. There are a lot of things that need to be arranged by a project manager, like making a design doc and managing the team’s workload.

Deep respect to all project managers out there doing it well.

Of course, in the end, it is not all about the project rather the interactions with the people in the team are very important.

In regard to this aspect, I feel that I have done a good job. My relationship with the trainees I led has nothing but improved. We communicate more, we are able to joke together as friends. I am able to teach them and communicate my thoughts with them clearly.

In my opinion, I think socially I am already viable enough. Communication with higher-ups and other teams were also great.

In the end, the project is planned to have its phase 2 of development. I have other projects so I will not be continuing my role. Thus, the role of the project manager will fall to someone else.

Conclusion

In conclusion, I really enjoyed the opportunity to lead my own project. It really helped me understand the flaws I have in leadership and gave me a path to further improve myself.

The company received the project well since they plan on having a phase 2 to further develop it, making it into something better.

Being the initiator is truly a dream come true. To all the people who believed. Thank you. Mistakes were made, but from them, we learn new things. On that note, here is a good quote to end it.

The master has failed more times than the beginner has tried - Stephen McCranie

DEV Community: Agustinus Theodorus

How to Deploy Flutter Web to Netlify Using CI/CD and Azure Pipelines

Installing Dependencies

1. Installing the Flutter plugin

2. Installing the Nelitfy plugin

Creating your Netlify site

1. Install Netlify CLI

2. Log in to Netlify from the CLI

3. Creating a blank site

4. Retrieving your Site ID and personal access token

Creating the CI/CD Pipeline

1. Creating the CI pipeline

2. Creating the CD pipeline

Summary

Setting Up A Multinode RabbitMQ Cluster On Linux

What is clustering for?

Add the required dependencies

Install the required repositories

Add Hostname to the hosts file

Setting Up RabbitMq Server

Install RabbitMq Server

Open Ports

Start the RabbitMq service

Enable RabbitMq Management

Setting Up RabbitMq Cluster

Setting Up The Master Node

Setting Up The Slave Nodes

Join The Slave Nodes With The Master Node

Reset The Master Node

Check The Cluster Status

Conclusion

The Microservice Architecture Perspective

One Down, Many More To Go

Pay For What You Need

Separate Your Interests

Scale More!

Small and Compact

More Autonomy and Faster Development Speeds

With Great Power Comes Great Documentation

Reusability

Conclusion

Automating Flutter Web Deployments to Netlify Using GitHub Actions

Creating Your Netlify Site

1. Install the Netlify CLI

2. Log in to Netlify from the CLI

3. Creating a blank site

4. Retrieving your Site ID and personal access token

Set Repository Secrets

Retrieving the GitHub Access Token

Creating the CI/CD Workflow

Summary

Automate Your Linux Deployment Using Azure DevOps

Installing Azure Agent on Linux

1. Setting Up A Deployment Group in Azure DevOps

2. Installing the Agent on the Linux Server

Configure your Linux server for automation

1. Make a script to automate NGINX configurations

2. Make a script to automate system service configurations

3. Setup a user to run systemctl and Nginx commands without password prompts

Prepare the Pipelines

Prepare the CI Pipeline

Prepare the CD Pipeline

Testing the pipeline

Summary

How To Choose Your First Techstack

The Job Stack

The Swiss Army Stack

Javascript

Python

Dart

The Mature Stack

So, which should I choose?

Conclusion

How To Host Flutter Web In Linux Using Nginx

What would you need?

Umm, first of all, a private server.

Do we need to install the Flutter SDK on our server?

Do I need a domain?

Build your app

Configure Nginx

Add Hostname to the `hosts` file