Netlify is an all-in-one platform for automating modern web projects. Replace your hosting infrastructure, continuous integration, and deployment pipeline with a single workflow. Integrate dynamic functionality like serverless functions, user authentication, and form handling as your projects grow.

In this article, we will create a to-do app with React and Appwrite and then we will proceed to deployment via Netlify.

Step 1: Installation

Install the Appwrite via Gitpod like this. It will make you install Gitpod and a few steps of authorization. If you choose to open the IDE in the browser, it will configure and show up like the below image.

Click on the Simple Browser in the workspace.

Step 2: A new project.

Sign in and create a new project. For creating a todo app, add a new Web App in Appwrite.

Enter the endpoint of your website according to your choice. (<project-name>, <project-name>.netlify.app)

Step 3: Databases

Create a new Database. Create a new collection with the following properties.

Add the following permissions to your collections. These permissions ensure that only registered users can access the collection.

Step 4: Frontend

Create a new folder on the desktop (or any other favorite spot) to set the front end. Fork and git clone this repo in this new folder.

Follow these instructions to run the demo app locally:

$ git clone https://github.com/appwrite/todo-with-react
$ cd todo-with-react

Run the following command to generate your .env vars

$ cp .env.example .env

Now fill in the environment variables in your .env file as below:

• REACT_APP_ENDPOINT — Your Appwrite endpoint.
• REACT_APP_PROJECT — Your Appwrite project ID.
• REACT_APP_COLLECTION_ID — Your Appwrite collection ID.
• REACT_APP_DATABASE_ID — Your Appwrite database ID.

Now run the following commands and you should be good to go:

$ npm install
$ npm start

Step 5: Deploy

To deploy it, head over to https://www.netlify.com and set up your account if not already.

Click add a new site → import an existing project.

Select GitHub and then your forked repo.

In a few minutes, the website will be ready and the URL will be available on the dashboard. By default, Netlify creates websites with URLs ending by .netlify.app.

Check out my website here: React App (stalwart-syrniki-c71317.netlify.app)

Happy coding.

Step 1: Create Azure SQL VM Image

Navigate to Azure SQL and + add SQL deployment option.

In the resource type of SQL virtual machine, select and create Free SQL server License: SQL server 2019 developer on windows server 2022.

Fill out the instance details and in the Image list, select the image with the version of SQL Server and Windows operating system. Also, make sure to change the size to A2 v2. Fill in other details accordingly.

In the SQL Server setting under the Networking section, select public SQL connectivity and 1401 port. Under SQL Authentication, select Enable.

Click Review + Create.

Step 2: Connect to SQL server

Download SQL server management studio (SSMS) from here.

Open C:\Program Files (x86)\Microsoft SQL Server Management Studio 18\ Common 7\ DTASHELL.

Now copy the IP address of the virtual machine and put it in the Server name column along with port 1401. In the Authentication box, select SQL Server Authentication. In the Login box, type the name of a valid SQL login and password.

Thanks.

Multi-factor Authentication is a security tool which make sures that the users have two or more factors of authentication to access application, account or service. This verification measure protects users and their data from security breaching and unauthorize access.

Steps to set up multi-factor authentication on Azure AD:

Step 1: Set up Multi-factor authentication

First of all navigate to Azure AD. On the left column look for Users.

Open Users and select the user on which you are willing to apply MFA.

Now click Per-user MFA. You will probably land on a page similar to following one.

Select the user and click Enable available under quick steps.

Confirm multi-factor auth.

You should receive a confirmation pop-up.

Step 2: Login via Multi-factor auth.

Log out from azure portal.

Now on your phone, go to play store and install Microsoft Authenticator.

Sign in new application.

Now if we try to login on computer, select other ways to sign in.

Select Approve a request on my Microsoft authenticator app.

On your phone you will get a new notification.

Upon approval of the request, it’ll automatically log in to your account on azure.

This example is only one type of multi-factor authentication. MFA includes tons of services in actuality . Explore and try out.

Thanks.

In the previous article, we covered how to set up a resource group via Terraform and Azure CLI. In this article, I will be covering how to construct a monolithic architect via Terraform. It would include VNet, subnet, Network interface, Network security group, Disk, IP address range, storage account, and virtual machine.

Step 1: Install Terraform and Azure CLI

Refer to my previous blog to download Terraform and Azure CLI. Download and put it in a folder having read and write access.

Now run “az login” to authenticate via Powershell running as an administrator.

Step 2: Configure the architecture

In order to create an architect, we first need to write configuration files.

In the same folder add a few files.

1. providers.tf

terraform {
required_version = ">=0.12"
required_providers {

azurerm = {
source = "hashicorp/azurerm"
version = "~>2.0"
}
}
}
provider "azurerm" {
features {}
}

2. main.tf

resource "random_pet" "rg-name" {
  prefix    = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  name      = random_pet.rg-name.id
  location  = var.resource_group_location
}

# Create virtual network
resource "azurerm_virtual_network" "myterraformnetwork" {
  name                = "myVnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

# Create subnet
resource "azurerm_subnet" "myterraformsubnet" {
  name                 = "mySubnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.myterraformnetwork.name
  address_prefixes     = ["10.0.1.0/24"]
}

# Create public IPs
resource "azurerm_public_ip" "myterraformpublicip" {
  name                = "myPublicIP"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  allocation_method   = "Dynamic"
}

# Create Network Security Group and rule
resource "azurerm_network_security_group" "myterraformnsg" {
  name                = "myNetworkSecurityGroup"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

security_rule {
    name                       = "SSH"
    priority                   = 1001
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "*"
    destination_address_prefix = "*"
  }
}

# Create network interface
resource "azurerm_network_interface" "myterraformnic" {
  name                = "myNIC"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

ip_configuration {
    name                          = "myNicConfiguration"
    subnet_id                     = azurerm_subnet.myterraformsubnet.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.myterraformpublicip.id
  }
}

# Connect the security group to the network interface
resource "azurerm_network_interface_security_group_association" "example" {
  network_interface_id      = azurerm_network_interface.myterraformnic.id
  network_security_group_id = azurerm_network_security_group.myterraformnsg.id
}

# Generate random text for a unique storage account name
resource "random_id" "randomId" {
  keepers = {
    # Generate a new ID only when a new resource group is defined
    resource_group = azurerm_resource_group.rg.name
  }

byte_length = 8
}

# Create storage account for boot diagnostics
resource "azurerm_storage_account" "mystorageaccount" {
  name                     = "diag${random_id.randomId.hex}"
  location                 = azurerm_resource_group.rg.location
  resource_group_name      = azurerm_resource_group.rg.name
  account_tier             = "Standard"
  account_replication_type = "LRS"
}

# Create (and display) an SSH key
resource "tls_private_key" "example_ssh" {
  algorithm = "RSA"
  rsa_bits  = 4096
}

# Create virtual machine
resource "azurerm_linux_virtual_machine" "myterraformvm" {
  name                  = "myVM"
  location              = azurerm_resource_group.rg.location
  resource_group_name   = azurerm_resource_group.rg.name
  network_interface_ids = [azurerm_network_interface.myterraformnic.id]
  size                  = "Standard_DS1_v2"

os_disk {
    name                 = "myOsDisk"
    caching              = "ReadWrite"
    storage_account_type = "Premium_LRS"
  }

source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

computer_name                   = "myvm"
  admin_username                  = "azureuser"
  disable_password_authentication = true

admin_ssh_key {
    username   = "azureuser"
    public_key = tls_private_key.example_ssh.public_key_openssh
  }

boot_diagnostics {
    storage_account_uri = azurerm_storage_account.mystorageaccount.primary_blob_endpoint
  }
}

3. variables.tf

variable "resource_group_name_prefix" {
  default       = "rg"
  description   = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

variable "resource_group_location" {
  default       = "eastus"
  description   = "Location of the resource group."
}

4. output.tf

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "public_ip_address" {
  value = azurerm_linux_virtual_machine.myterraformvm.public_ip_address
}

output "tls_private_key" {
  value     = tls_private_key.example_ssh.private_key_pem
  sensitive = true
}

Step 3: Creating the architecture

On the PowerShell running as an administrator, run the following to initialize and validate:

terraform init
terraform validate

Next, Terraform will plan a set of actions and eventually applies to finally create our resources. Type:

terraform plan
terraform apply

And finally,

Now, as indicated by the terminal, our resources are added and ready to use.

To verify, navigate to the Azure portal.

Thanks.

Creating single-tier architecture on Azure via Terraform. was originally published in Towards Dev on Medium, where people are continuing the conversation by highlighting and responding to this story.

Follow along to install terraform on Powershell and create a resource group using it.

Step 1: Install Terraform

To install Terraform, we have to first install chocolatey. Run Powershell as administrator and write following commands:

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

For more details, refer to this.

Now we install Terraform. In same Powershell window run:

choco install terraform

Step 2: Install Azure CLI

Start powershell as adminstrator and run:

$ProgressPreference = 'SilentlyContinue'; Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi; Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'; rm .\AzureCLI.msi

This will download or update the latest version of Azure CLI.

Next, we login via Powershell into Azure account:

az login

Step 3: Create a resource group

Now create a folder, not in the administrative section.

Copy terraform.exe from ‘C:\ProgramData\chocolatey\lib\terraform\tools’ to your new folder.

Also, make Azure CLI available there.

Add following files in that folder:

1. providers.tf

terraform {

required_version = ">=0.12"
  
  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}

provider "azurerm" {
  features {}
}

2. main.tf

resource "random_pet" "rg-name" {
  prefix    = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  name      = random_pet.rg-name.id
  location  = var.resource_group_location
}

3. variables.tf

variable "resource_group_name_prefix" {
  default       = "rg"
  description   = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

variable "resource_group_location" {
  default = "eastus"
  description   = "Location of the resource group."
}

4. output.tf

output "resource_group_name" {
    value = azurerm_resource_group.rg.name
}

Now we initialize the configuration in the power shell, run:

terraform init 

Next, we validate and plan:

terraform validate
terraform plan

The terraform plan command creates an execution plan, but doesn't execute it. Instead, it determines what actions are necessary to create the configuration specified in your configuration files.

terraform apply

Hence a new resource group is created named “rg-direct-stud”.

Navigate to the Azure portal to verify.

Thanks.

Install Terraform on Windows with Azure PowerShell was originally published in AWS Tip on Medium, where people are continuing the conversation by highlighting and responding to this story.

The File Transfer Protocol (FTP) is a standard communication protocol used for the transfer of computer files from a server to a client on a computer network.

FileZilla is a free and open-source, cross-platform FTP application, consisting of FileZilla Client and FileZilla Server. Clients are available for Windows, Linux, and macOS, servers are available for Windows only.

Step 1: Create a virtual machine

On the Azure portal, create a new Windows virtual machine.

Connect to the instance via RDP.

On the virtual machine open Server Manager. Click add Roles and Features. Click next until you reach Server Roles. Select Web Server(IIS).

Click Next. On Role Services, select FTP Service, FTP Extensibility.

Click Next and finally install. It would take a while.

Step 2: Configuration

Navigate to Tools on top right bar of server manager. Click on Computation Management.

Under Local Users and Groups, click on Groups and create a new group. I have named my new group “ftp”.

In the Users section, create a new user. Give it a name and password.

Now we add the user in our new group. On the properties of the new group, add user.

Now we create a folder on the desktop, “new”. Add one or two text files. Right click and open properties > open share. Add user1. Also, do the same for advanced sharing.

Allow full control, change, and read permission for user1.

Next, go back to Server Manager and under Tools. Click IIS Manager.

Under the VM > Sites > Add FTP Site.

Give it name and it’s physical address.

Under SSL, select No SSL. Click Next.

Under Authentication select Basic. For Authorization, allow access to specific roles or user groups. Type your group name under. Set up both read and write permission and click finish.

Step 3: Installing FileZilla and Connect

Open the browser and search FileZilla download. Install FileZilla.

To connect to the FTP server via FileZilla, type the following information as shown in the orange box. For host write ftp://VM_IPv4_address. Also, fill the physical path to the folder on the Local site. Leave the port at default. Click Quickconnect.

You can see the files under that folder reflected at the Remote site as well (Files A and B). Moreover, it displays a successful status.

That is how we install an FTP server in a virtual machine and connect to it via FileZilla.

Thanks.

FTP server on a virtual machine was originally published in AWS Tip on Medium, where people are continuing the conversation by highlighting and responding to this story.

A managed image is a resource that is created from a VM that is generalized. These images are then stored as a managed disk or an unmanaged disk. A managed VM image contains the information necessary to create a VM, including the OS and data disks. The virtual hard disks (VHDs) that make up the image, including both the OS disks and any data disks, are stored as managed disks.

Managed images can create more virtual machines with the same configuration.

Step 1: Create a virtual machine

Create a basic Windows virtual machine in the desired region. Make sure it contains enough disk size.

Now, connect to the instance via RDP.

Open PowerShell on the VM and paste the following command to install google chrome.

$LocalTempDir = $env:TEMP; $ChromeInstaller = "ChromeInstaller.exe"; (new-object    System.Net.WebClient).DownloadFile('http://dl.google.com/chrome/install/375.126/chrome_installer.exe', "$LocalTempDir\$ChromeInstaller"); & "$LocalTempDir\$ChromeInstaller" /silent /install; $Process2Monitor =  "ChromeInstaller"; Do { $ProcessesFound = Get-Process | ?{$Process2Monitor -contains $_.Name} | Select-Object -ExpandProperty Name; If ($ProcessesFound) { "Still running: $($ProcessesFound -join ', ')" | Write-Host; Start-Sleep -Seconds 2 } else { rm "$LocalTempDir\$ChromeInstaller" -ErrorAction SilentlyContinue -Verbose } } Until (!$ProcessesFound)

Type “start chrome” to open chrome.

Step 2: Generalize the machine

To generalize the machine:

First delete C:/Windows/Panther

Remove-Item C:/Windows/Panther

Next, navigate to the C:\Windows\system32\sysprep directory. And run:

.\sysprep.exe

Select Generalize.

Select Shutdown from the dropdown. The machine will shut down automatically. Do not restart.

Inform the Azure portal about the Generalization of the machine. Open Azure Powershell and type:

Set-AzVm -ResourceGroupName celebal -Name VM -Generalized

Step 3: Create a managed image

Click on Capture on the overview page of VM. Select No, capture only a managed image. Click Review + Click.

Step 4: Create a VM from the image

To create a virtual machine, go to the overview page of the image.

Click Create VM. Name the new virtual machine and click Review+ Create.

And with that, you’ve crossed another level to becoming a boss coder. GG! 👏

I hope you found this article instructional and informative. If you have any feedback or queries, please let me know in the comments below. And follow SelectFrom for more tutorials and guides on topics like Big Data, Spark, and data warehousing.

The world’s fastest cloud data warehouse:

When designing analytics experiences which are consumed by customers in production, even the smallest delays in query response times become critical. Learn how to achieve sub-second performance over TBs of data with Firebolt.

Install Chrome on VM and Replicate It with Managed Image was originally published in SelectFrom on Medium, where people are continuing the conversation by highlighting and responding to this story.

Step 1: Create a storage account

You can either create a new storage account or can use an existing account. To create a new account navigate to storage accounts on the azure portal. Name a globally unique name for your storage account and appropriate region. Click Review + Create.

Step 2: Create File Share

Once your storage account is ready to use, look for File shares. Create a new file share.

Name the file share and click create with the rest values set to default.

When it is done, edit the quota on the overview page. Well, this is optional.

Step 3: Mount on your local system

Click Connect.

Copy the script and run it on Powershell.

Check it on your PC.

Hence, a file share is successfully mounted on the device.

Thanks.

• Metric alerts
• Log alerts
• Activity log alerts
• Smart detection alerts

Let’s set up an alert rule for VM CPU percentage using Azure Monitor.

Step 1: Create a virtual machine

Create a basic virtual machine in your resource group and region. Leave rest at default values. Click Review + Create.

Step 2: Create Alert

After the virtual machine is deployed, look for alerts in left column.

Click Create alert rule.

Now search for “percentage CPU”. Select the only option.

Now, in the aggregation type select Total. Set the threshold value to 80%. Also, Aggregation granularity (Period) to 1 minute. Click Done.

Next, on the action group page, create a new action group and name it. Click Next.

You will land on the Notification page. Select Email/Message/Voice etc. Give it a name. Select the email option and jot down your email address. Leave rest of the options and click OK. Move forward.

Next, name the alert rule on the Details page. Finally, click Review + Create.

Before you click create for the last time. You can go ahead and test your alert by specifying some details too. This is an optional step.

That is all, you will be timely notified next time your CPU percentage approaches to 80% margin.

Thanks.

The scenario:

Create 3 subnets under a virtual network: Web tier, App tier, DB tier

Configure Network Security Group such that:

• DB tier should not access any tier (Web & App)
• The app tier should access the DB tier and Web tier.
• The web tier should only access the App tier.
• Only the web tier should have access to the internet.

The steps are pretty easy, here we go:

Step 1: Create VNet

Create a virtual network with three subnets and non-overlapping CIDR ranges.

Step 2: Create Virtual Machines

For each subnet, we will be creating a basic virtual machine as shown.

The first is for the Web tier.

The next one is for the app tier. I have denied all public inbound initially.

Lastly for the DB subnet. I have denied public inbound here too.

Step 3: Configure the network security rules

In order to configure the network rule for any VM, we have to go to the Setting then Networking page of the respective VM.

And to test the connection, we will Log in to the SSH of the respective VM.

Firstly testing the Web VM. It should allow the ping for all other instances of the same network.

Yes, it does.

Now if we try to connect to the SSH of other VMs, it’ll deny.

Let’s change the networking inbounds of App-VM.

We have added two rules in inbound:

Allow SSH, Allow from Web-VM

and three rules in outbound:

Allow to Web-VM, Allow to DB-VM, Deny to internet of App-VM.

Next, we configure DB-VM.

The outbound rules are set to default.

We have added an inbound port rule: Deny web-vm.

Next, the Web instance already has the necessary ports by default.

That is how we configure network security rules.

Thanks.