The Syntax Difference Between Python and PowerShell

by Contributed | Oct 6, 2020 | Uncategorized

This article is contributed. See the original author and article here.

During MS Ignite 2020, I was surprised to learn of a growing debate that system administrators are starting to become increasing vocal on…

“Which scripting language is better? Python or PowerShell?”

Having only dabbled in both, I am not an authority on either to share my opinion.  From a fact’s perspective, PowerShell provides a shell scripting environment whereas Python is an interpreted high-level programming language. Both can accomplish similar tasks but thier differences also help distinguish themselves to complete certain tasks.

So why not use both?  

This was a question I began to research for this post and thought it would be an innovative idea to compare the similarities in syntax between Python and PowerShell.  In conducting said research I came across the work by Adam Driscoll, an 8 year MVP in the Cloud and Datacenter space and added a few subtle changes. 

Here is the reference between PowerShell and Python language syntax. Let us know in the comments below if something is missing or should be added.
 

Syntax Reference
 

Arrays

@('Hello', 'World')

['Hello', 'World']

$arr = @('Hello', 'World')
$arr[0]
# Hello

arr = ['Hello', 'World']
arr[0]
# 'Hello'

$arr = @('Hello', 'World')
$arr.Length

arr = ['Hello', 'World']
len(arr)

$arr = @('Hello', 'World')
$arr += "Friend"

arr = ['Hello', 'World']
arr.append('Friend')

 $arr = [System.Collections.ArrayList]@('Hello', 'World')
 $arr.RemoveAt($arr.Count - 1)

arr = ['Hello', 'World']
arr.pop(1)

 $arr = [System.Collections.ArrayList]@('Hello', 'World')
 $arr.Remove("Hello")

arr = ['Hello', 'World']
arr.remove('Hello')

 
Casting

$i = [int]"10"

i = int("10")

$i = [float]"10.5" 

i = float("10.5")

$i = [string]10

i = str(10)

Classes

class MyClass {
    $x = 5
}

class MyClass:
  x = 5

[MyClass]::new()

MyClass()

class Person {
    Person($Name, $Age) {
        $this.Name = $Name
        $this.Age = $Age
    }

    $Name = ''
    $Age = 0
}
[Person]::new('Orin', 40)

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("Orin", 40)

class Person {
    Person($Name, $Age) {
        $this.Name = $Name
        $this.Age = $Age
    }

    [string]myfunc() {
        return "Hello my name is $($this.Name)"
    }

    $Name = ''
    $Age = 0
}
[Person]::new('Thomas', 32)

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("Thomas", 32)
p1.myfunc()

Conditions

$a = 33
$b = 200
if ($b -gt $a)
{
    Write-Host "b is greater than a"
}
elseif ($a -eq $b)
{
    Write-Host "a and b are equal"  
}
else
{
  Write-Host "a is greater than b"
}
  

a = 33
b = 200
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

Comments

# Hello, world!

# Hello, world!

<# 
Hello, world!
#>

"""
Hello, world!
"""

Data Types

$var = 1
$var | Get-Member
#or
$var.GetType()

var = 1
type(var)

Dictionaries

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
print(thisdict)

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
$thisdict.brand
$thisdict['brand']

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
thisdict['brand']

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
$thisdict.brand = 'Fiat'

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
thisdict['brand'] = 'Fiat'

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
$thisdict.Keys | ForEach-Object {
    $_
}

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
for x in thisdict:
    print(x)

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
$thisdict.Values | ForEach-Object {
    $_
}

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
for x in thisdict.values():
    print(x)

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
if ($thisdict.ContainsKey("model"))
{
    Write-Host "Yes, 'model' is one of the keys in the thisdict dictionary"
}

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
if "model" in thisdict:
  print("Yes, 'model' is one of the keys in the thisdict dictionary")

$thisdict = @{
  brand = "Dodge"
  model = "Challenger"
  year = 1970
}
$thisdict.color = 'Plum Crazy Purple'

thisdict = {
  "brand": "Dodge",
  "model": "Challenger",
  "year": 1970
}
thisdict["color"] = "Plum Crazy Purple"

Functions

function my-function()
{
  Write-Host "Hello from a function"  
}
my-function

def my_function():
  print("Hello from a function")

my_function()

function my-function($fname, $lname)
{
    Write-Host "$fname $lname"
}
  

my-function -fname "Anthony" -lname "Bartolo"

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Anthony", "Bartolo")

function my-function()
{
    Write-Host "$($args[2])"
}
  
my-function "Sarah" "Pierre" "Rick"

def my_function(*team):
  print("The team member is " + team[1])

my_function("Sarah", "Pierre", "Rick")

function my-function($team3, $team2, $team1)
{
    Write-Host "The youngest team member is $team3"
}
  
my-function -team1 "Rick" -team2 "Pierre" -team3 "Sarah"

def my_function(team3, team2, team1):
  print("The youngest team is " + team3)

my_function(team1 = "Rick", team2 = "Pierre", team3 = "Sarah")

function my-function
{
    param(
        $country = "Canada"
    )

    Write-Host "I am from $country"
}

def my_function(country = "Canada"):
  print("I am from " + country)

function my-function($x)
{
    5 * $x
}
  

def my_function(x):
  return 5 * x

Lambdas

$x = { param($a) $a + 10 }
& $x 5

x = lambda a : a + 10
print(x(5))

Loops

$fruits = @("strawberry", "banana", "mango")
foreach($x in $fruits)
{
    Write-Host $x
}
  

fruits = ["strawberry", "banana", "mango"]
for x in fruits:
  print(x)

$i = 1
while ($i -lt 6)
{
    Write-Host $i
    $i++
}

i = 1
while i < 6:
  print(i)
  i += 1

$i = 1
while ($i -lt 6)
{
    Write-Host $i
    if ($i -eq 3)
    {
        break
    }
    $i++
}

i = 1
while i < 6:
   print(i)
   if i == 3:
     break
  i += 1

$i = 1
while ($i -lt 6)
{
    Write-Host $i
    if ($i -eq 3)
    {
        continue
    }
    $i++
}

i = 1
while i < 6:
   print(i)
   if i == 3:
     continue
  i += 1

Operators

$var = 1 + 1

var = 1 + 1

$var = 1 - 1

var = 1 - 1

$var = 1 * 1

var = 1 * 1

$var = 1 / 1

var = 1 / 1

$var = 1 % 1

var = 1 % 1

[Math]::Floor(10 / 3)

10 // 3

[Math]::Pow(10, 3)

Packages

Install-Module PowerShellProtect

pip install camelcase

Import-Module PowerShellProtect

import camelcase

Get-Module -ListAvailable

pip list

Strings

"Hello"

"Hello"
'Hello'

"Hello
World
"

"""Hello
World"""

$str = 'Hello'
$str[0]
# H

str = 'Hello'
str[0]
# 'H'

$str = 'Hello'
$str.Length

str = 'Hello'
len(str)

$str = ' Hello '
$str.Trim()
# Hello

str = ' Hello '
str.strip()
# 'Hello'

$str = 'HELLO'
$str.ToLower()
# hello

str = 'HELLO'
str.lower()
# 'hello'

$str = 'hello'
$str.ToUpper()
# HELLO

str = 'hello'
str.upper()
# 'HELLO'

$str = 'Hello'
$str.Replace('H', 'Y')
# Yello

str = 'Hello'
str.replace('H', 'Y')
# 'Yello'

'Hello, World' -split ','
# @('Hello', ' World')

str = 'Hello, World'
str.split(',')
# ['Hello', ' World']

$array = @("Hello", "World")
$array -join ", "
[String]::Join(', ', $array)

list = ["Hello", "World"]
", ".join(list)

$price = 40
$txt = "The price is {0} dollars"
$txt -f $price

price = 40
txt = "The price is {} dollars"
print(txt.format(price))

$price = 40
$txt = "The price is {0} dollars"
$txt -f $price

price = 40
txt = "The price is {0} dollars"
print(txt.format(price))

$price = 40
"The price is $price dollars"

price = 40
f"The price is {price} dollars"

Try Catch

try {
    Write-Host $x 
} catch {
    Write-Host "An exception ocur Plum Crazy Purple"
}

try:
  print(x)
except:
  print("An exception occur Plum Crazy Purple")

Variables

$var = "Hello"

var = "Hello"

$global:var = "Hello"

global var
var = "Hello"

Use MITREid Connect for OAuth2 Authorization in API Management

by Contributed | Oct 5, 2020 | Uncategorized

This article is contributed. See the original author and article here.

Use MITREid Connect for OAuth2 Authorization in API Management

By (alphabetically): Akinlolu Akindele, Dan Balma, Maarten Van De Bospoort, Minhui Burket, Nick Drouin, Heba Elayoty, Andrei Ermilov, Tom Fleming, David Giard, Michael Green, Alfredo Chavez Hernandez, Hao Luo, Siva Mullapudi, Kamil Somaj, Nsikan Udoyen, William Zhang

Introduction

Using an API gateway in front of REST APIs is a common design pattern which allows us to offload the cross-cutting capabilities such as OAuth2 authorization to the gateway instead of letting security code get scattered in application code. Azure API Management (APIM) is such an API gateway service. For the common case that the OAuth2 server in APIM is Azure AD (AAD), it has been well documented. In this document we will cover the case that the OAuth2 server is MITREid Connect instead of AAD.

MITREid Connect is an open source Identity Provider, popular in Java community. MITREid Connect is compliant to OpenID Connect and OAuth 2.0 protocol. This document is based on MITREid Connect v 1.3.3.

Prerequisites

1. An Azure subscription
2. A MITREid Connect instance. This document focuses on how to enable OAuth2 over APIM and MITREid Connect, instead of on how to set up MITREid Connect.
3. A REST API app for test. The REST API could be deployed to AKS, App Service, or other. Or use this sample REST API with Swagger http://conferenceapi.azurewebsites.net/?format=json.
4. Familiar with Azure API Management
5. Basic understanding of OAuth2. OAuth2 involves a few specs (OAuth2, OIDC, PKCE and JOSE). A list of good references on OAuth2 and related specs can be found here.

NOTE: This article does not cover the security between APIM and the REST API which is a separate topic. If a REST API is deployed to AKS, there are a few options which have been documented in Use Azure API Management with microservices deployed in Azure Kubernetes Service.

If APIM Premium is used, we can leverage VNET so that the security between APIM and AKS is simpler. Otherwise, we need to secure the REST calls from APIM to AKS thru technique such as mutual TLS (mTLS) (note that it is mutual TLS, not just TLS). This could be the topic of a future document.

Preparations in MITREid Connect

In order to prepare for OAuth2 setup in APIM, we need to perform the following steps in MITREid Connect:

1. Register a server application registration;
2. Define its scopes;
3. Register a client application;
4. Specify its permissions: either Delegated Permissions or Application Permissions;
5. Create a client secret.

The concepts and the steps for the above OAuth2 steps between MITREid Connect and Azure AD are not fundamentally different. You may get detailed steps from Protect an API by using OAuth 2.0 with Azure Active Directory and API Management

The following parameters from MITREid Connect must be prepared and available for our setup in APIM.

Create an OAuth2 Server on MITREid Connect

1. In Azure portal left menu column, click “OAuth 2.0”
2. Click “Add” button on the right pane
3. You need the following parameters to create the OAuth 2 server on MITREid Connect:
   • Client ID
   • Client secret
   • Authorization endpoint
   • Token endpoint

For Authorization grant types, you may choose to checkmark the following:

1. Authorization code
2. Client credentials

For Default scope, you can either leave it blank or enter any valid scope as defined in MITREid Connect client registration.

You can keep Resource owner username and Resource owner password as blank.

For additional details on creating OAuth2 server in APIM, please see this document.

Set up a REST API App in APIM

1. Create an API Management service by following this document.
2. Import a REST API by following this document.
3. Make sure to disable subscription-key authorization which is enabled by default.
   1. Click on “APIs” menu in the left menu column
   2. Select the API you are working with in the mid-column
   3. In the right pane, select Settings tab at the top
   4. Uncheck Subscription required under Subscription section. This ensures that subscription-key authorization is not used since we intend to use OAuth2 authorization.

Customize API Inbound Policy

  <validate-jwt header-name="Authorization" failed-validation-httpcode="401" failed-validation-error-message="Unauthorized. Access token is missing or invalid.">
        <openid-config url="[openid-config endpoint]" />
        <required-claims>
              <claim name="aud">
                 <value>[audience]</value>
              </claim>
              <claim name="iss">
              <value>[issuer]<value>
              </claim>
              <claim name="scope">
                 <value>[scope 1]</value>
                 <value>[scope 2]</value>
              </claim>
        </required-claims>
  </validate-jwt>

The openid-config endpoint is the OpenID Config URL from MITREid Connect. It is critical to make sure you have the correct URL since this is the URL thru which APIM acquires JWKS (JSON Web Key Set) for JWT validation.

The values for audience and *issuer” are from MITREid Connect and can be found from its token sample.

For *scope” claim, you can have 0, 1 or multiple scope values. Notice that if you have mutlipel scope values, it means AND (all required) instead of OR (one of scope values is enough).

Troubleshooting Guide

In OAuth2 authorization, it is typical to have multiple parts involved in the authorization flow:

Unauthorized (401) Issue

The most common error in OAuth2 authorization is Unauthorized (401). This could be caused by any of the following:

1. Incorrect openid-config endpoint in API inbound policy
2. Incorrect *iss” value in API inbound policy
3. Incorrect “aud” value in API inbound policy
4. Incorrect “scope” values in API inbound policy. If you can capture a sample JWT token, you can parse it via a tool like http://aka.ms/jwt to see its claims values. These values are determined by registered server application in MITREid Connect and the API permission configurations for the registered client application.
5. Incorrect Security settings in the API. Check the *Settings” tab of the API and make sure that *User authorization” is OAuth 2.0 and the right OAuth 2.0 server is selected in the OAuth 2.0 server dropdown.

Subscription-key Issue

By default, when an API is installed into APIM service, its subscription-key authorization is enabled. Make sure it is disabled since we use OAuth2 instead of subscription-key. You can find its settings under Settings tab in the API.

CORS Issue

If your test client is a web or SPA client and you use javascript to make API calls with OAuth2 authorization, you will likely face CORS issue since the web app or SPA is from different domain as APIM. By default, an API in APIM does not support CORS preflight and you need to enable it in inbound policy.

Inbound section:

  <cors allow-credentials="true">
        <allowed-origins>
            <origin>http://localhost:3000</origin>
        </allowed-origins>
        <allowed-methods preflight-result-max-age="300">
            <method>GET</method>
            <method>POST</method>
            <method>PATCH</method>
            <method>DELETE</method>
            <method>PUT</method>
        </allowed-methods>
  </cors>

Outbound section:

  <outbound>
     <base />
     <set-header name="Access-Control-Allow-Origin" exists-action="override">
           <value>@(context.Request.Headers.GetValueOrDefault("Origin",""))</value>
     </set-header>
     <set-header name="Access-Control-Allow-Credentials" exists-action="override">
           <value>true</value>
     </set-header>
  </outbound>

Custom header issue

Another potential issue is: for a production REST API, it has custom headers such as transaction or correlation ID for logging and troubleshooting. Such correlation ID may be scoped to the enterprise or the service itself.

However, there is a restriction to access response headers when you are using javascript Fetch API over CORS. Due to this restriction, by default you can access only following standard headers:

• Cache-Control
• Content-Language
• Content-Type
• Expires
• Last-Modified
• Pragma

More info on this restriction can be found here.

In order to allow such client to get access to custom headers (such as correlation ID), we need to add the following section in our inbound/cors section:

  <allowed-headers>
        <header>content-type</header>
        <header>accept</header>
        <header>authorization</header>
        <header>x-correlation-id</header>
        <header>x-my-request-id</header>
  </allowed-headers>
  <expose-headers>
        <header>x-correlation-id</header>
        <header>x-my-request-id</header>
  </expose-headers>

Terraform for Deployment

Needless to say, it is desirable to have the creation and configuration automated. We could use Terraform for this purpose. Detailed document on Terraform Azuure API Management Resources can be found here.

The Terraform (.tf file) should cover the following tasks:

1. Create a resource group
2. Create an API Management service
3. Create a product
4. Add a REST API into the product
5. Disable subscriptin key authorization in the REST API
6. Import a prepared inbound policy (XML) into the REST API
7. Add OAuth2 Server based on MITREid Connect
8. Configure REST API settings

In addition to the variables defined in variables.tf file, the Terraform also requires a XML policy file as input. In the policy file, the following parameters (XML node/attribute values) are required.

The APIM inbound policy with these parameters is critical in ensuring the following to work:

• Token introspection
• CORS policy
• Custom header accessibility

Microsoft Drivers 5.9.0 Preview 1 for PHP for SQL Server Released

by Contributed | Oct 5, 2020 | Uncategorized

This article is contributed. See the original author and article here.

We recently released the next preview of the Microsoft Drivers for PHP for SQL Server, version 5.9.0-preview1. This preview release has been built with PHP 7.2+ and tested on all supported platforms.

Notable items about this release include:

Added

• Support for PHP 8.0 RC 1
• Support for Ubuntu 20.04 and Alpine 3.12
• Support for GB18030 locale #1115
• Feature Request #924 – extended PDO errorinfo to include additional odbc messages if available – pull request #1133
• Data Classification with rank info, which requires MS ODBC Driver 17.4.2+ and SQL Server 2019 or an Azure SQL instance that supports it

Removed

• Dropped support for Ubuntu 19.10 and Debian 8.

Fixed

• Pull Request #1127 – removal of TSRMLS macros in preparation for PHP 8 by remicollet
• Pull Request #1136 – improved performance when handling decimal numbers as inputs or outputs and removed unncessary conversions for numeric values
• Pull Request #1143 – if an exception occurs when executing a query, will not change the output parameters
• Pull Request #1144 – use the correct C types when binding output parameters with integer values
• Pull Request #1146 – improved performance when fetching numbers using client buffers
• Pull Request #1165 – setting query timeout without using LOCK TIMEOUT, which saves an extra trip to the server
• Issue #1170 – when fetching large data types such as ntext will check more than only the display size – pull request #1172

Limitations

• No support for inout / output params when using sql_variant type
• No support for inout / output params when formatting decimal values
• In Linux and macOS, setlocale() only takes effect if it is invoked before the first connection. Attempting to set the locale after connecting will not work
• Always Encrypted requires MS ODBC Driver 17+
  • Only Windows Certificate Store and Azure Key Vault are supported. Custom Keystores are not yet supported
  • Issue #716 – With Always Encrypted enabled, named parameters in subqueries are not supported
  • Issue #1050 – With Always Encrypted enabled, insertion requires the column list for any tables with identity columns
  • Always Encrypted limitations

Known Issues

• This preview release requires ODBC Driver 17.4.2 or above. Otherwise, a warning about failing to set an attribute may be suppressed when using an older ODBC driver.
• Connection pooling on Linux or macOS is not recommended with unixODBC < 2.3.7
• When pooling is enabled in Linux or macOS:
  • unixODBC <= 2.3.4 (Linux and macOS) might not return proper diagnostic information, such as error messages, warnings and informative messages.
  • due to this unixODBC bug, fetch large data (such as xml, binary) as streams as a workaround. See the examples here.

Survey

Let us know how we are doing and how you use our drivers by taking our pulse survey.

Install

• On Linux and macOS run the commands below:

sudo pecl install sqlsrv-5.9.0preview1
sudo pecl install pdo_sqlsrv-5.9.0preview​1

• To download Windows DLLs for PHP 7.2 or above from the PECL repository, please navigate to SQLSRV or PDO_SQLSRV.
• Direct downloads for released binaries can also be found at the Github release tag.

David Engel

Introducing our New Data Type: Date & Time Extended

by Contributed | Oct 5, 2020 | Uncategorized

This article is contributed. See the original author and article here.

The Access team has implemented a new data type: Date & Time Extended, which enhances syntax compatibility with SQL server, and increases the accuracy and level of detail in records that include dates and times. This investment aligns with our broader goal of building Access apps on top of data that can be stored in the cloud.

See attributes:

As indicated in the table above, this new data type has a larger date range and greater fractional precision than the existing Date & Time data type in Access. However, Access’s current Date & Time data type will continue to operate as-is; we will not remove it.

SQL Compatibility

Our new Date & Time Extended type is compatible with SQL’s DateTime2 type; therefore, when you import or link to a SQL Server table, you can map the Access Date & Time Extended field to SQL’s Datetime2 field without losing date range or time precision.

Keep in Mind

1. This supports SQL Server version 2016 and after.
2. Date & Time Extended requires the use of Microsoft ODBC Driver for SQL Server 11 or later. We recommend using Microsoft ODBC Driver 13.1 for SQL Server.

Backward Compatibility

The Date/Time Extended data type is supported in Microsoft Access 365 but is not compatible with non-subscription (perpetual) versions of Microsoft Access. As a result, if the data type is implemented within a local Access table and that Access database is shared with a non-subscription version of Access, you will not be able to open the database in your non-subscription version.

Expression Support

You can use a number of expressions on our data type, including DateAdd, DateDiff, and more (see full list of expressions here).

For more advanced developers, you can also leverage SQL Aggregate Functions and expressions. For example, you can use LoggedDateTime as a field with the Date/Time Extended data type:

Using the Date/Time Extended data type as a string in VBA

As of today, you cannot perform calculations on the data type in VBA code, however you can use the new data type in VBA as text (string). The following VBA example uses Data Access Object methods to display, enter, and evaluate the Date/Time Extended data type based on the table below.

Table name:   DTETable
ID data type:   Autonumber
DTEData data type:   Date/Time Extended
DTData data type:  Date/Time

If you’d like to reference the type in VBA code, please be aware that expressions on the type are not supported, given that the data will be casted as a text. However, performing calculations of the new type in VBA code is an investment that the Access team is planning for at a later date.

Formatting   

All formats for Date/Time are supported for Date/Time Extended.

For more information, see Using the Date/Time Extended data type.

On behalf of the Access team, we’d appreciate your feedback, and we hope you enjoy this new feature! :smiling_face_with_smiling_eyes: