Categories
Cloud

Integrating Gumroad and WordPress

Gumroad is one of the hottest new ways for creatives to sell their products and services online. And with WordPress being one of the most popular content management systems in the world right now, in this post we’ll explore how you can connect both systems together to offer paid products and services from your WordPress blog.

There are 3 ways in which you can connect Gumroad with your WordPress site:

  • Via the free, official Gumroad plugin
  • Using the HTML embed codes
  • Via a paid third-party WordPress plugin

Free, official Gumroad plugin

Free (WordPress Plugin Marketplace)

This is the easiest free way to connect Gumroad and your website. You simply install the free Gumroad plugin from the Plugins section of your WordPress administration site.

The plugin adds a Gutenberg block that can be used within your content.

Unfortunately that’s about as advanced as you can get when using the official plugin. There’s no support for syncing paying customers between Gumroad and WordPress for sites such as online courses or membership areas. For that you’ll need to use a third-party plugin.

HTML embed codes

Gumroad provides HTML code that you can manually insert on your product pages within WordPress.

You can choose from an overlay, where a customer performs the entire flow from within a modal window on your site or an embed which can redirect customers to the Gumroad site to complete the transaction.

To generate the code, simply open your product within the Gumroad website, click “Share” and copy and paste the code from either “Overlay” or “Embed” into your WordPress post.

3rd-party WordPress plugin

If you’re looking for something more advanced – perhaps to restrict your content & blog posts to paying customers – then you may want to turn to a premium third-party WordPress plugin.

ProductPress (paid, pricing starting at $39) is one of the more established products in this space, allowing you to setup sites for things like online courses and membership sites.

These plugins rely on the Gumroad API to integrate deeper into your WordPress installation – so make sure if you are using a third-party plugin that it’s legitimate and not going to compromise your customer data or Gumroad account.

Categories
Azure Azure DevOps

Getting started with Azure Bicep

Bicep is a new language from Microsoft that allows you to easily specify your Azure infrastructure as code.

It’s an improvement on writing Azure Resource Manager (ARM) templates directly by better supporting features such as type safety and code modularity and reuse.

That said, Bicep still has a very close relationship with ARM templates. In fact, it’s an abstraction over ARM templates with templates written using Bicep able to be transpiled back to ARM templates. And if you have a bunch of existing ARM templates, they can be transpiled and converted into Bicep files.

Let’s now take a look at how you can get started using Bicep.

Preparing your environment

There’s a few things you’ll want to install in order to start using Bicep.

First you’ll want to download Visual Studio Code (free) and install the Bicep extension (also free). This will give you an editor in which to write your Bicep files, and the extension adds handy features such as Intellisense code suggestions and template validation to ensure the correct syntax.

You’ll also need to install the Bicep command line interface (CLI). The easiest, cross-platform way to do this is by installing the Azure command line interface. But if you’re after an alternative, see this list.

Become a Bicep guru

Dive deeper into Bicep with our getting started with Bicep course on Udemy today!

Writing your first Bicep file

Open Visual Studio Code, and create a new file called HelloWorld.bicep. In it, paste the following code:

resource appConfig 'Microsoft.AppConfiguration/[email protected]' = {
  name: 'bicepDemoAppConfig'
  location: 'westus2'
  sku: {
    name: 'standard'
  }
}

In this template, we’re creating an App Configuration service in Azure. Lets breakdown the template:

appConfig provides a local resource name for use within the template if you need to refer to this resource as a dependency, or from within another resource.

Microsoft.AppConfiguration/[email protected] refers to the resource type and the values that can be configured. See this Microsoft documentation for a full list of resource types.

As such, name, location and sku are all values that can be set for the resource type.

Next steps

To learn how to deploy this template, or to find out about more advanced Bicep topics including for loops, conditional statements and modularised templates check out our Udemy course on getting started with Bicep.

Categories
Cloud

Setting Digital Ocean environment variables

Are you trying to work out how to setup environment variables for your Digital Ocean droplet or app running on the app platform? Here’s how.

Digital Ocean droplet environment variables

Setting an environment variable for a droplet is a little more complicated than for an app running on the app platform.

Follow these steps to set environment variables on a Linux droplet:

  1. SSH into your droplet. If you’re not sure how to do that, see here
  2. Once connected, run the following command to set your environment variable:
export YOUR_VARIABLE_KEY=<your-variable-value>

App platform environment variables

To set environment variables for an app running on Digital Ocean’s app platform, follow these steps:

  1. Login to the Digital Ocean portal
  2. Open your app
  3. Click the “Settings” tab
  4. Scroll down until you see “App-Level Environment Variables”
  5. Click “Edit” and add the environment variable key and value
  6. Click “Save”

Your environment variable will now be available for your app.

Categories
Azure

How to create an Azure app service with a database

Need to deploy your app to an Azure app service, and rely on a database such as Postgres or Azure SQL?

Microsoft is now previewing a new blade in the Azure portal that lets you quickly spin up an Azure app service with an associated database.

Supported database engines for the preview are Postgres or serverless Azure SQL server.

To get started using the new blade, click here or search the Azure Marketplace for “web app database”.

The blade – currently in preview – is fairly basic compared to the normal app service blade, but allows you to specify the app name, runtime and database engine. You can also set the server name and database name.

By default it’ll spin up an app service using the Premium V2 tier, but you can scale this down (or up if required) once the service is created using the regular Azure scale up settings.

The database connection information will automatically be set as environment variables for your app service.

Categories
Google Tables

How to use Google Tables outside the US

Google recently launched a new product called Tables – a lightweight database similar to the likes of Airtable.

However being in beta, and launched by Google’s incubator Area 120, it’s only officially available in the United States for now.

But if you’re outside the US, at least for now you can still access Tables using the following method. Note that the usual caveats apply, in that Google may block this at any time and your success may vary.

  1. Sign up for a free trial of a VPN with a United States point of presence, such as encrypt.me
  2. Configure your computer/Mac/phone to use the VPN. Normally that involves downloading an app provided by your VPN provider.
  3. Enable the VPN, and open the Google Tables site. Click “Get started” in the top right-hand corner to login.
  4. You should get prompted to sign in with your Google Account. Enter your Google credentials, and as long as your VPN is active you should be able to login and start using Tables.
  5. If you’re not able to login still, make sure your VPN is located in the United States. To configure this in encrypt.me, go to Preferences > Transporter > North America > United States and choose a location.
Categories
Google Tables

Meet Google Tables – Google’s Airtable competitor

Google – through its incubator Area 120 – recently announced its own Airtable competitor, Tables. In this post we’ll take a look at how you can get started with Tables.

Meet Google Tables

What is Google Tables?

Think of Tables as a lightweight spreadsheet, similar to Microsoft Access database, or a competitor to Airtable. Using bots, you can create automations that do everything from emailing people when rows are added or changed, to modifying other rows or posting to a webhook.

Google Tables beta, available now in the United States.

Is Tables free?

Yes, there’s a free plan available. However it limits the number of rows you can have in a table to 1000, and you can only have 100 tables in total.

The paid plan ups that to 10,000 rows across 1000 tables, as well as providing more generous attachment sizes and actions.

Why use Tables instead of Google Sheets?

At this point Sheets are far more advanced than Tables. If you’re after functionality like formulas, you’ll want to stick to Sheets.

Tables really shines for lightweight data, like form responses and datasets that you might otherwise look to store in a database.

Be sure to check out Tables pricing too, as Sheets might be able to meet your needs for free.

Also note that Tables is still a part of Google’s incubator Area 120. As such it’s essentially still classified an experiment unlike Sheets, which is a fully-fledged Google product. This means there is no guarantee of Tables continued availability – particularly given Google’s history of losing interest in its experiments.

What other features does Tables have?

Tables allow you to create forms to allow anyone to input data into your tables. The form title, description and submission message can be customised, as can the layout of fields on the page. Each field maps to a field in your table, and can be hidden or marked as required.

The other powerful feature of Tables is automations via Bots. Bots allow you to perform various actions based on a set list of triggers, which include insertion or deletion of rows, column value changes, and cron or time-based.

What’s the difference between a workspace and a table?

A workspace is a collection of tables. Each table stores a particular set of data, organised into columns and rows. Workspaces can be shared with other people.

Where is Tables available?

Officially at the moment only those located in the United States can use Tables. But if you’re still keen to try it out, follow these steps to get access from anywhere.

Categories
Microsoft Teams

Microsoft Teams training resources

So your team is looking to start using Microsoft Teams as a form of internal communication? We’ve compiled a list of the best Microsoft Teams training resources for getting everyone up to speed about how to make the most out of the service.

While this list is far from conclusive, many of the resources below cover end-user and admin training, while some are more targeted to one scenario or the other.

Microsoft training

Free, Microsoft Training

If you’re looking for the best free training, it’s hard to go past Microsoft’s official training resources. Microsoft has created training for admins and end-users.

And if reading guides isn’t your thing, they even run free instructor-led sessions that anyone can sign up for, and run on a frequent basis.

Microsoft Teams essential training

Paid, LinkedIn Learning

One of the most-watched Microsoft Teams courses on LinkedIn Learning, this course will run you through the basics of setting up a Microsoft Teams workspace.

It then dives into incorporating the best of Teams functionality into your team’s workflow. A quiz at the end of each chapter helps recap what you just learnt.

Mastering Microsoft Teams Training

Paid, Udemy

While this training was recorded last year, the majority of the content remains relevant when using Microsoft Teams. Heavily focused on end-user functionality, this course won’t satisfy those looking for admin tips.

The course has some good content, and can be had at a more affordable price than the LinkedIn Learning course.

Adopt & Embrace Microsoft Teams

Paid, Amazon

If a book is more your thing, and you’re after a book that covers integrating Microsoft Teams within your team’s workflow then Adopt & Embrace Microsoft Teams is a solid buy.

The book covers integrating Microsoft Teams from a manager’s perspective, and includes chapters on getting to know Teams, through to some principles and best practices.

Categories
Azure DevOps

How to fix Azure DevOps library group permission errors

Are you trying to edit a variable group in an Azure DevOps Library, and getting the error “you do not have permission to create a variable group within library“? Continue on to find out how to rectify this issue.

The problem

DevOps project settings – these don’t apply to variable groups

Variable groups within Azure DevOps can have different permissions to your project settings. This can be useful to limit the number of people who can view and edit your config values, but can be confusing.

As such, while you may have appropriate permissions to edit and your project you may find yourself unable to create variable groups within your Azure DevOps instance.

If this has happened to you, you’ll be shown an error something along the lines of “Error: you do not have permission to create a variable group within library.”

The fix

Luckily there’s a quick fix to this issue, although it will require you to find someone with the correct administrator privileges first.

Once you’ve found the person who has the correct privileges, navigate to your project in the DevOps portal, and create a new group. Alternatively, if this is an existing group click on the title of the group you wish to edit.

If you did create a new group, name it and make sure at least one variable exists. Note that this can be a dummy value – but without a variable DevOps won’t let you save the new group.

Then, within the edit group screen, select “Security“. The title of the modal that appears should be something like “Assign security roles for Library/<your group name>”. If it’s not, make sure you selected the group first and that you haven’t clicked “Security” from the main Library screen.

Security roles apply to variable groups

DevOps libraries have 3 tiers of roles/permissions:

  1. Reader: Can only view items within the library
  2. User: Can use items within the library, but can’t edit them
  3. Administrator: Can use AND manage items within the library

Search for the user(s) you want to be able to add and edit variables (and to avoid the above error) and choose the “administrator” role.

Click “Add”, close the modal and then click “Save”. The above error should no longer occur for users trying to edit or create variables in the DevOps library.

Categories
Microsoft Graph

What is the Microsoft Graph?

Ever heard someone mention the Microsoft Graph and not known what it is? In this article, we’ll dive deeper into what the graph is and what it can provide you access to.

What is the Microsoft Graph?

In a nutshell, the Microsoft Graph is designed to be a one-stop shop (ie a single endpoint) for interacting with the Microsoft suite of products. For now it’s limited to only a subset of Microsoft’s product range, but Microsoft has grand ambitions for continuing to grow this over time.

Delve, Excel, Microsoft Bookings, Microsoft Teams, OneDrive, OneNote, Outlook/Exchange, Planner, and SharePoint as well as many enterprise and mobility services are currently supported.

The key difference between the Microsoft Graph and Microsoft’s previous service-specific APIs is that the Graph is designed around user scenarios and is independent of the service that customers may interact with.

For example, where previously you may have directly called anOutlook API to access a user’s calendar, using the Graph you simply interact with Calendar data directly without caring about the service.

One side-effect of the Graph is that instead of each Microsoft product having its own platform-specific SDK, you can use one SDK to access them all. You can find a full list of the SDKs here, but platforms include iOS, Android, .NET, PHP, Ruby and Python.

Does the API use GraphQL?

No – while the “Microsoft Graph” name may confuse some, the API itself is a normal REST API and doesn’t use GraphQL at this point in time.

Can anyone use the API or do you need to be a partner?

Anyone can sign up to use the Graph API for free.Many of the customer scenarios around email, contacts and calendars are available for use in production apps today.

Keep in mind that some APIs are still in beta (such as The ones backed by Microsoft Booking) and as such shouldn’t be used in production apps yet.

Categories
Azure

Creating your first Azure Resource Manager (ARM) template

If you’re manually creating infrastructure for your next app in Azure, you should consider using an Azure Resource Manager (ARM) template.

An ARM template is essentially a JSON file that describes the infrastructure you want to create in the Azure cloud. It can be run as many times as you like to spin up identically-configured environments.

Create the template

The first step when using an ARM template is to create the template file. If you’d rather start with an example template, Microsoft has an entire Github repo with some templates that you can clone.

The base template – normally called azuredeploy.json – is made up of the following structure:

{
  “$schema”: “https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#”,
  “ContentVersion”: “1.0.0.0”,
  “Resources”: []
}

The elements can be described as follows:

  • $schema: Refers to the properties that can be used within the template. If you were to load the URL in your web browser, it would return the elements and a description of each that you can use within your template. When uploading a template, these get validated to ensure you haven’t made any mistakes.
  • contentVersion: This is an internal version number for you to use to reference the current template. It should be in the format X.X.X.X, with X being any integer. You should only change this value in your template when a significant change is made.
  • resources: This is an array that will contain a description of all the Azure resources that your app or service needs. For now it’s empty.

Add resources to the template

As mentioned above, within the resources section of the template you need to describe the Azure services that you wish to provision. Each Azure service has a set of properties that can be set, with some mandatory. By default, a resource requires:

  • type: The type is a string that refers to a namespace of the resource provider and the name of the type of resource that you wish to provision. For example, Microsoft.DocumentDB/DatabaseAccounts implies you want to create a DatabaseAccount from the Microsoft.DocumentDB namespace
  • apiVersion: Similar to the template $schema version, each Azure resource type also publishes versions of their schema. This property allows you to specify which schema or version of the resource type you’d like to use and is mandatory
  • name: The human-readable string name that you’d like the resource to be called

While not mandatory, a location element is normally provided as well to specify the location where you want the resource to reside (eg. Australia East).

Luckily Microsoft publishes a full list of properties for each resource type. But if you’re still not sure, for most resources you can manually create the resource using the Azure Portal and go to the “Export Template” tab for the resource, and Microsoft will generate a template for you.

For this tutorial, let’s create a simple functions app. Add the following to your resources section in your azuredeploy.json file:

   "resources": [
        {
            "type": "Microsoft.Web/sites",
            "apiVersion": "2018-02-01",
            "name": "[parameters('siteName')]",
            "kind": "functionapp,linux",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
            ],
            "properties": {
                "name": "[parameters('siteName')]",
                "siteConfig": {
                     "appSettings": [
                        {
                            "name": "FUNCTIONS_WORKER_RUNTIME",
                            "value": "python"
                        },
                        {
                            "name": "FUNCTIONS_EXTENSION_VERSION",
                            "value": "~2"
                        }
                    ]
                },
                "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]",
                "clientAffinityEnabled": false
            }
        },
        {
            "type": "Microsoft.Web/serverfarms",
            "apiVersion": "2018-02-01",
            "name": "[variables('hostingPlanName')]",
            "location": "[parameters('location')]",
            "kind": "linux",
            "properties":{
                "reserved": false
            },
            "sku": {
                "Tier": "Dynamic",
                "Name": "Y1"
            }
        }
    ]

The above creates a Linux App Service hosting plan. It uses the consumption function tier (Y1) and isn’t a reserved plan.

The template also creates a function app (Microsoft.Web/sites) that dependsOn the hosting plan.

If you look closely, you might notice that some elements refer to variables and parameters. Let’s dive deeper into what they are.

What are parameters?

Parameters allow you to specify a value each time you deploy a template. For example, if you had a template and wanted to create a production and staging environment with it, you could create a environment parameter that would allow you to specify staging or production in resource names without modifying the template file each time.

If you didn’t use a parameter, you’d need to change the hard-coded string value in your azuredeploy.json file each time you wanted to change to a new environment.

Similarly if you wanted to be able to deploy your template to a different Azure location quickly, you could specify a location parameter. Then you could deploy to any Azure region by simply providing a new location parameter value – with no change to the template file required.

Within the template file, parameters sit in a top-level parameters element as follows:

{
  “$schema”: “https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#”,
  “ContentVersion”: “1.0.0.0”,
  “Resources”: [],
  “Parameters”: {
    “hostingPlanName”: {
      “type”: “string”,
      “DefaultValue”: “”,
      “Metadata”: {
           “Description”: “The name to give your hosting plan”
      }
   }
}

Parameters support a number of elements, but the most common include:

  • type: The type of value provided (eg. String)
  • defaultValue: A default value to use if one isn’t provided when the template is deployed
  • metadata.description: A description of what the parameter represents

Parameters can be set when deploying using the Azure CLI or PowerShell. Here’s an example of how you would provide a location parameter using the Azure CLI:

az group deployment create \
  —-name mytemplatename \
  —-resource-group yourResourceGroup \
  —-templateFile $templateFile \
  —-parameters environment=staging

Referencing the parameter is done using the following syntax – you can see a full example in the template we defined earlier with resources:

"location": "[parameters('location')]"

What are variables?

While parameters allow you to specify values when deploying a template, variables allow you to reuse values internally within your template file without duplication. For instance, if you had a value that you use in 3 different resources (such as a location or in the example above the hostingPlanName) that you didn’t want to expose to those running your template you could use a variable.

Like parameters, variables are also top-level elements. They’re simpler to specify, as you don’t need to provide descriptions, types and default values. They look like this:

{
  “$schema”: “https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#”,
  “ContentVersion”: “1.0.0.0”,
  “Resources”: [],
  “Variables”: {
     “HostingPlanName”: “yourHostingPlanName”
  }
}

You can then reference the variable within your resource definitions using the following syntax as seen in the resources section in the template we created earlier:

"name": "[variables('hostingPlanName')]"

Summary

In this post, you’ve learnt about how a template is structured, and what each element means. Stay tuned for our next post on deploying your template.