To address the issue of building effective scripts and tools, PowerShell was built using .Net runtime. Due to the flexibility and the powerful command-line execution speed with support for multiple services, PowerShell is loved in the sysadmin and IT world to automate the repeating mundane tasks.

In this article, you'll discover the basics of PowerShell and what you can do with it.

What is PowerShell?

PowerShell is a fully functional programming and scripting language based on Microsoft .Net framework. It has built-in help and command discovery that lets you discover multiple layers of a framework. So whether you are running Windows, macOS, or Linux, you can use PowerShell for scripting.

As a scripting tool, PowerShell is commonly used for system automation for ongoing maintenance and testing. However, with the extensive functionality, it is getting popular with Azure Cloud to deploy and manage cloud resources programmatically.

What are PowerShell Commands and Cmdlets

PowerShell commands are based on lightweight functions that are designed to perform specific task sets. Therefore, cmdlets are also considered to be building blocks of PowerShell. They are designed to perform one particular action. PowerShell commands are called cmdlets, pronounced as "command-lets."

Some of the key functionalities of cmdlets are:

• The output of cmdlets is often in the form of an object or array of objects rather than a text string.

• The result of one command can be passed on (pipe) to another command during runtime.

• All the commands are case-insensitive. So, for example, geT-hElp and Get-Help yields the same results.

PowerShell Command Syntax

The PowerShell commands (cmdlets) follow a convention of using a verb and a noun combined with - (dash) in between them. Therefore, the format looks like this: Verb-Noun. Thus, while working on any core commands or external library, you will see a consistent pattern on calling the commands.

For example, to query the services running on your computer, you would use Get-Service. Similarly, you can set or perform other available actions as well.

Below is a comprehensive list of cmdlet patterns for the verb section of the command:

• Get → get the value of something

• Set → set or update the value of something

• New → create a new entry of something

• Start → start something

• Stop → stop something

• Restart → Restart something

• Out → output something

• Write → write something to terminal or shell

You can always find the list of commands by typing in Get-Command and review all available commands on your computer:

PowerShell Get-Command Output

What are PowerShell Modules

PowerShell module is a package that withholds PowerShell members, including functions, cmdlets, provider, workflow, variables, and aliases. The modules are written to solve a single set of problems or target a specific management area on a system.

Running the Get-Module -All gives you a list of all the installed modules on your computer. Refer to the example where you can see the name of the modules and all the commands each module offers:

PowerShell Get-Module Output

Commands that use PowerShell providers don't load automatically. Instead, you need to follow a specific process to install and import the modules before they are ready to use. More on this will be covered in a later article.

What is PowerShell Pipeline

PowerShell pipeline is series of commands connected by using a | (pipe) operator. The output object of one command can serve as an input object for another command. Thus, you can chain multiple commands as long as the data is valid in the following manner:

Command-1 | Command-2 | Command-3

To visualize it with an example, run the following command inside your terminal:

Get-Process | Sort-Object -Property ProcessName -Descending

PowerShell Get-Process Output

What are PowerShell Objects

With the origin of PowerShell from .Net and being an object-oriented language, every call to PowerShell commands is initializing a class for that module and returning the results. Therefore, the PowerShell objects are instances of classes that have properties and methods you can call.

Here's an analogy on how to understand more:

• Objects → set of items

• Cmdlets → actions you can perform on those items

• Modules → set of actions you can perform on any item

• Properties → detail about the items

• Methods → instructions for set of items

Common PowerShell Commands

While working with any scripting language, it's helpful to remember and familiarize yourself with some of the most common and well-known commands. In addition, most of the modules and commands come with specific instructions on how to use the module. Therefore, understanding where to find the information or help resources for any command is key to performing the task.

PowerShell Get-Verb

PowerShell Verb is an interesting concept. The idea of the verb is to define what you are trying to do with the data. Whether it's read, write, update, or insert, you are expected to follow a certain naming convention.

Run the Get-Verb command in your terminal to see the list of all the available actions:

PowerShell Get-Verb Output

The results may vary in your case. However, notice from the above image, the verbs are grouped (Group) based on their purpose and display an alias (AliasPrefix) that you can use to call the command without typing in the full name.

PowerShell Get-Member

PowerShell Get-Member command helps you display the list of methods, properties, and objects available for any command. In addition, any command that produces an output of type object can be further called upon with Get-Member to list the information.

Below is a sample command piped with Get-Member command:

PowerShell Get-Process Pipe Get-Member Output

PowerShell Get-Help

Another useful PowerShell command to be aware of in the beginning is the Get-Help command that can assist you in finding syntax and provide guidance on using all the available commands. For example, the output of Get-Help looks like this:

PowerShell Get-Help Output

To find the help on any command, type Get-Help, followed by any command you need help with. In the example above, the call for getting help on Get-Command looks like this:

PowerShell Help for Get-Command Output

Looking at the output, any command that has more than one parameter set contains a SYNTAX block. The elements in the [] square brackets are optional when running the command.

What are PowerShell Operators

PowerShell operators are commands available out-of-box to perform various operations to analyze and manipulate the data. Some of the common operators include:

• Equality → equal (-eq), not-equal (-ne), greater than (-gt), greater than or equal (-ge), less than (-lt), less than or equal (-le)

•     PS> 2 -eq 2 # Output: True PS> 2 -eq 3 # Output: False
  
      PS> "abc" -eq "abc" # Output: True PS> "abc" -eq "def" # Output: False
  
      PS> "abc" -ne "def" # Output: True PS> "abc" -ne "abc" # Output: False
  

• Matching → -like, -notlike, -match, -notmatch

•     PS> "PowerShell" -like "*shell" # Output: True
      PS> "PowerShell" -notlike "*shell" # Output: False
  
      PS> "PowerShell" -like "Power?hell" # Output: True
      PS> "PowerShell" -notlike "Power?hell" # Output: False
  
      # Partial match test, showing how differently -match and -like behave
      PS> "PowerShell" -match 'shell' # Output: True
      PS> "PowerShell" -like 'shell' # Output: False
  
      #Regex syntax test
      PS> "PowerShell" -match '^Power\w+' # Output: True
      PS> 'bag' -notmatch 'b[iou]g' # Output: True
  

• Containment → -in, -notin, -contains, -notcontains

    "abc", "def" -contains "def" # Output: True
    "abc", "def" -notcontains "def" # Output: False
  
    "Windows", "PowerShell" -contains "Shell" # Output: False
    "Windows", "PowerShell" -notcontains "Shell" # Output: True
  
    "abc", "def", "ghi" -contains "abc", "def" # Output: False
    "abc", "def", "ghi" -notcontains "abc", "def" # Output: True
  

• Type → -is, -notis

    $a = 1 $b = "1"
  
    $a -is [int] # Output: True
    $a -is $b.GetType() # Output: False
  
    $b -isnot [int] # Output: True
    $a -isnot $b.GetType() # Output: True
  

• Replace → -replace

Conclusion

I hope you find this useful!

Now you know what PowerShell is and understand the basics of how it works. This will go a long way if you plan to use PowerShell for either general system automation or even automating the cloud resources using Azure PowerShell.

In the meantime, check out the other articles in the PowerShell series:

• PowerShell Basics: How to use PowerShell Help?

• PowerShell Basics: Format Command Output as Tables, List, and More

• Azure PowerShell DSC

Azure App Service is a fully managed Platform as a Service (PaaS) that provides you with the tools and services needed to create reliable and scalable mission-critical Web Apps, Mobile Apps, API Apps, and Logic Apps in a single instance. It takes away your management of the host and lets you focus entirely on building your application for performance.

With the ability to develop and deploy enterprise-ready web applications, it provides powerful DevOps capabilities such as continuous integration with Azure DevOps, GitHub and Docker Hub, stage management, custom domain, and TLS/SSL. You can always integrate the app service with your on-premises resources if ever needed.

Check out some of the key features of App Service:

• Multiple languages and frameworks - App Service support ASP.NET, ASP.NET Core, Java, Ruby, Node.js, PHP, or Python. You can always run WebJobs on your web app using PowerShell or other scripting languages.
• Managed production environment - App Service is fully managed resources that take away your effort to manage, patch, update, or upgrading any underlying OS. You can spend time writing great apps and let Azure worry about the platform.
• Containerization and Docker - Does the code work on your machine only? Dockerize your application and publish it on App Service. You can run multi-container apps with Docker Compos.
• DevOps optimization - You can set up continuous integration and deployment with Azure DevOps, GitHub, BitBucket, Docker Hub, or Azure Container Registry. This allows you to deploy your application directly using CI/CD.
• Global scale with high availability - Being a managed resource, you get the ability to scale up or out the app service resource manually or automatically. App Service allows rules to trigger the scaling for your application based on its workload metrics.
• Connections to SaaS platforms and on-premises data - App Service allows you to choose from more than 50 connectors for enterprise systems (such as SAP), SaaS services, and internet services (such as Facebook). You can also access your on-premises data using Hybrid Connections and Azure Virtual Networks right within the application settings.
• Security and compliance - Authentication with Azure AD and other third party authentication service make it easier for you to leverage the feature with very little change in your application code.
• Application templates - If you are getting started, choose from an extensive list of application templates in the Azure Marketplace, such as WordPress, Joomla, and Drupal with very little to zero experience of deploying web apps.
• Visual Studio and Visual Studio Code integration - Do you love working with Visual Studio tools? You can use Visual Studio or VS Code to create, deploy, and debug your application in real time without any additional setup.
• Serverless code - Serverless fan? App Service got you! You can run code snippets or script on-demand without having to explicitly provision or manage infrastructure and pay only for the compute time your code actually uses. Check out Azure Functions or Logic App for more information on how to achieve that.

Conclusion

Start using Azure App Service today and explore the feature to see what works best for you! If you are looking for more information, check out the other articles in the series and get started with App Service.

References

Overview - Azure App Service

If it's your first time here, please check out other articles in the series:

Part 1: Up and Running with Azure App Service

Part 2: Continuous Deployment for Azure App Service

Are you still running your web servers on Linux or Windows-based VMs in the cloud? When was the last time you checked how much resources your web app is using and whether you need to scale it up or down to improve performance or save cost? Probably, not so often!

The whole point of being in the cloud is leveraging the ability to run scalable and resilient infrastructure without compromising user experience. If you are using cloud services and still practicing the traditional route of using VMs instances for development, you clearly haven't migrated to the cloud yet! Start using the services that are built for the purpose so that you uncover all the possibilities of improvement and enhancement in your application that you would not think of otherwise.

In this article, I'll be providing a high-level overview of the exact tools that you need to build modern, scalable, resilient, and redundant applications all with cost-saving in mind so that you only pay for what you use.

What is Azure App Service?

Microsoft provides a solution to host web-based services in form of application, REST APIs, or mobile backend known as Azure App Service. It's similar to a web server, but here you only focus on your code instead of updating your host for patches every other week. With the wide range of support for the language, you can deploy your application in .NET, .NET Core, Java, Python, Ruby, PHP, or Node.js. App Service support running application at scale on either Windows or Linux based environment.

App Service is the easiest way of running your application in Azure as it lets you focus on creating the application code, not on running it. Let's see what App Service can do and how it can solve your application needs.

App Service Capabilities and Functionality

Azure App Service includes a wide variety of functionality including auto-scaling, load-balancing, automated deployment, and security integration with Azure AD. As the demand for CI/CD and automation increases, App Service lets you configure those DevOps capabilities and configure the deployments using GitHub, Azure DevOps, Docker Hub, and may other sources..

Let's explore some of the core features that App Service offers and how you can leverage them to solve your business needs.

App Service Plan

As with any traditional web service, you need a hosting server where the code will be published and hosted. Azure offers that with "App Service Plan" that provides you with a fully isolated and dedicated environment to securely run your applications at a high scale. Think of this as Azure VM running in a secure environment that is fully managed by Azure.

As of today, you can choose from the following pricing tier for using an app service plan.

• Shared Compute: App Service Plan offers two-tier on shared compute, Free and Shared which runs your services on the same Azure VM, sharing the underlying host instance. The resources are allocated for each customer instance that runs on the shared resource based on the chosen tier.
• Dedicated Compute: If you choose to run your service on a dedicated host, you get three tiers to choose from. The Basic, Standard, and Premium tier offers you a dedicated host that hosts only the services you choose to run on top of them.
• Isolated Instance: If you ever need to run your service or application without any connection or exposure to other instances in the same Azure network, Isolated Instance provides you with a fully isolated compute option running on a dedicated Azure virtual network which can integrate with your local virtual network for network-level isolation.

Operating System Support

With the mixture of Linux and Windows-based web services in the cloud, App Services also allows you to choose the type of operating systems that you need so that your application architecture doesn't suffer and it provides the same runtime environment that your application needs for your code to function properly.

Since the App Service is a managed service, you don't get direct access to the host operating systems that the apps run on. Likewise, if you are hosting a container in App Service, you still get full access to your container instance through but not the host it runs on.

Deployment Slots

Deployment Slot is one of the features in App Service that provides more value than you'd expect. It lets you create a slot for your application and act as a fully-functional version of your production application. It gives you an opportunity to test your application in your App Service environment before pushing directly to production.

Let's suppose your application takes 2-5 minutes(may vary in your case) to warm up and perform initial tasks before it's functional, you would not want your customers to wait for that long whenever a new update is released. That's where you'd use Deployment Slot by creating a new slot and switch the slot with your production app when your application is ready and running as normal. It is as simple as clicking one button to switch your slots and push your code to production.

Check out more details at the link below:

https://docs.microsoft.com/en-us/azure/app-service/deploy-staging-slots?WT.mc_id=parveensingh.com

Deployment Center

Are you already using GitHub or Azure DevOps as your code repository? If yes, Integrate it right within your application and get a seamless deployment experience without any complex setup.

Deployment Center enables you to connect your Application with any repository for continuous delivery and code change updates. App Service supports continuous deployment from Azure DevOps, GitHub, and Bitbucket where app services pull the latest changes seamlessly from the source control to keep your app code up to date.

More information at the link below:

https://docs.microsoft.com/en-us/azure/app-service/deploy-continuous-deployment?WT.mc_id=parveensingh.com

Scale Up-Out

How would you scale your application if it's running on an Azure VM? Probably shut it down and resize, right? Hold right there!

The scale-out feature has just the right configuration that you need for your application to scale automatically without even touching it. Whether you want 1 or 10 instances of your application, the auto-scaling feature provides you just that with a simple rule setup defined with pre-configured conditions that will trigger resource creation and destruction based on the workload of your application.

See what else can you do with Scaling in Azure:

https://docs.microsoft.com/en-us/azure/app-service/manage-scale-up?WT.mc_id=parveensingh.com

Authentication and Authorization

If you are building any production running application, chances are that you are either handling the Authentication and Authorization in your code or using a third-party module to support that feature. Luckily, Microsoft provides you with direct integration of application authorization and authentication without you worrying about all the maintenance and management.

Since App Service uses the Federated Identity, you can integrate any major identity provide in your codebase like Azure Active Directory, Microsoft Account, Facebook, Google, and Twitter along with support for other OpenID Connect providers as well.

More in-depth information below:

https://docs.microsoft.com/en-us/azure/app-service/overview-authentication-authorization?WT.mc_id=parveensingh.com

Backups

Backups are a crucial part of running the application in production where you'd want to make sure you have a safe copy of your application in case you need to roll back to the previous date. App Service provides you with an in-built option to enable backups for your application with support for one-click restore to either a different application or overwriting existing app.

Check out more in-depth information on the article below:

https://docs.microsoft.com/en-us/azure/app-service/manage-backup?WT.mc_id=parveensingh.com

Custom Domains and SSL

If you are running your application in Azure, you should set up your own domain as an entry point instead of azurwebsites.com subdomain provided by Microsoft for free. App Service allows you to either purchase a domain directly from the app service options or connect your existing domain by verifying the domain membership.

Domain Verification usually involves adding a CNAME and A record for either root or subdomain based on what you are adding. Since Shared Infrastructure is intended to be used for development only, Custom Domain is not supported in "F1 Shared Infrastructure" as you'd need to be on at least "D1 Shared Infrastructure" plan to support the customer domain and B1 Plan, if you want to bind an SSL certificate to your application.

Refer to the article below for more information:

https://docs.microsoft.com/en-us/azure/app-service/app-service-web-tutorial-custom-domain?WT.mc_id=parveensingh.com

Application Insights

Is your application performing the way you expect it to? Well, App Service got Application Insights that you tell you exactly what you need to know from the hardware level to application-level diagnostics of your application. All it takes is to add a simple piece of code to your application and let the data come through application insights where you can monitor the real-time performance of your application. How cool is that?

Conclusion

I hope you got at least a brief overview of what Azure App Service is. I'll be covering in-depth tutorials in the coming weeks on using CI/CD Pipelines with Azure App Service.

Looking for information or article on any particular Azure Service? Leave a comment down below or reach out to me on Twitter.