Workflow orchestration has always been a pain for data scientists, but this is exacerbated in these AI hype days by agentic workflows executing arbitrary (not pre-defined) workflows with a variety of failure modes. Adam from Prefect joins us to talk through their open source Python library for orchestration and visibility into python-based pipelines. Along the way, he introduces us to things like Marvin, their AI engineering framework, and ControlFlow, their agent workflow system.

Join the discussion

Changelog++ members save 9 minutes on this episode because they made the ads disappear. Join today!

Sponsors:

• WorkOS – A platform that gives developers a set of building blocks for quickly adding enterprise-ready features to their application. Add Single Sign-On (Okta, Azure, Google, Microsoft OAuth), sync users from any SCIM directory, HRIS integration, audit trails (SIEM), free magic link sign-in. WorkOS is designed for developers and offers a single, elegant interface that abstracts dozens of enterprise integrations. Learn more and get started at WorkOS.com
• Shopify – Sign up for a $1/month trial period at shopify.com/practicalai
• Notion – Notion is a place where any team can write, plan, organize, and rediscover the joy of play. It’s a workspace designed not just for making progress, but getting inspired. Notion is for everyone — whether you’re a Fortune 500 company or freelance designer, starting a new startup or a student juggling classes and clubs.

Featuring:

• Adam Azzam – Twitter, LinkedIn
• Chris Benson – Twitter, GitHub, LinkedIn, Website
• Daniel Whitenack – Twitter, GitHub, Website

Show Notes:

• Prefect
• Marvin
• ControlFlow

Something missing or broken? PRs welcome!

Summary

Mads Torgersen talks about what's new in C# 13, and some of what might be coming in C# 14.

Details

Upcoming release of C# 13, .NET Conf 2024. Params collections, use cases. Overload resolution priority. System.Threading.Lock, why a new lock type. Ref struct types, the underbelly of C#. Update on discriminated unions, but years away. Preview features - field keyword properties, extension everything.

Support this podcast

Full show notes
What's new in C# 13
C# Language Design - GitHub

When setting up your infrastructure in Azure, using the Azure Verified Modules can streamline the creation of any Azure Resource such as Azure Web Apps for Windows and Linux with App Service Plans. This post guides you through the code for doing just that, I leave it to you to create the parameters and fill them in 

//MARK: App Insights Instance
@description('Create Application Insights Instance')
module createAppInsights 'br/public:avm/res/insights/component:0.4.1' = if (deployWebApps) {
  scope: resourceGroup(resourceGroupArray[2].name)
  name: 'createAppInsights'
  params: {
    name: appInsightsName
    workspaceResourceId: logAnalytics.outputs.resourceId
    diagnosticSettings: [
      {
        workspaceResourceId: logAnalytics.outputs.resourceId
      }
    ]
  }
  dependsOn: [
    logAnalytics
  ]
}

//MARK: App Service Plan Windows
//Deploy an azure web app with App service plan for Windows
module appServicePlanWindows 'br/public:avm/res/web/serverfarm:0.2.4' = if (deployWebApps) {
  scope: resourceGroup(resourceGroupArray[2].name)
  name: 'appServicePlanWindows'
  params: {
    name: 'aspwin-${customerName}-${environmentName}-${locationShortCode}'
    location: location
    tags: tags
    skuName: skuNameAppServicePlanWindows
    kind: skuKindAppServicePlanWindows
    skuCapacity: skuCapacityAppServicePlanWindows
    diagnosticSettings: [
      {
        workspaceResourceId: logAnalytics.outputs.resourceId
      }
    ]
  }
  dependsOn: [
    logAnalytics
  ]
}

//MARK: App Service Windows
module appServiceWindows 'br/public:avm/res/web/site:0.9.0' = if (deployWebApps) {
  scope: resourceGroup(resourceGroupArray[2].name)
  name: 'appService'
  params: {
    name: 'appwin-${customerName}-${environmentName}-${locationShortCode}'
    kind: 'app'
    location: location
    tags: tags
    serverFarmResourceId: appServicePlanWindows.outputs.resourceId
    managedIdentities: {
      systemAssigned: false
      userAssignedResourceIds: [
        managedIdentity.id
      ]
    }
    diagnosticSettings: [
      {
        workspaceResourceId: logAnalytics.outputs.resourceId
      }
    ]
    siteConfig: {
      alwaysOn: true
      http20Enabled: false
      appSettings: [
        {
          name: 'APPINSIGHTS_INSTRUMENTATIONKEY'
          value: createAppInsights.outputs.instrumentationKey
        }
      ]
    }
    appInsightResourceId: createAppInsights.outputs.resourceId
  }
  dependsOn: [
    logAnalytics
    appServicePlanWindows
    createAppInsights
  ]
}

//MARK: App Service Plan Linux
//Deploy an azure web app with App service plan for Linux
module appServicePlanLinux 'br/public:avm/res/web/serverfarm:0.2.4' = if (deployWebApps) {
  scope: resourceGroup(resourceGroupArray[2].name)
  name: 'appServicePlanLinux'
  params: {
    name: 'asplinux-${customerName}-${environmentName}-${locationShortCode}'
    location: location
    tags: tags
    skuName: 'P1v3'
    kind: skuKindAppServicePlanLinux
    zoneRedundant: false
    diagnosticSettings: [
      {
        workspaceResourceId: logAnalytics.outputs.resourceId
      }
    ]
  }
  dependsOn: [
    logAnalytics
  ]
}

//MARK: App Service Linux
module appServiceLinux 'br/public:avm/res/web/site:0.9.0' = if (deployWebApps) {
  scope: resourceGroup(workloadsResourceGroupArray[2].name)
  name: 'appServiceLinux'
  params: {
    name: 'applin-${customerName}-${environmentName}-${locationShortCode}'
    kind: 'app'
    location: location
    tags: tags
    serverFarmResourceId: appServicePlanLinux.outputs.resourceId
    managedIdentities: {
      systemAssigned: false
      userAssignedResourceIds: [
        managedIdentity.id
      ]
    }
    diagnosticSettings: [
      {
        workspaceResourceId: logAnalytics.outputs.resourceId
      }
    ]
    siteConfig: {
      alwaysOn: true
      http20Enabled: false
      appSettings: [
        {
          name: 'APPINSIGHTS_INSTRUMENTATIONKEY'
          value: createAppInsights.outputs.instrumentationKey
        }
      ]
    }
    appInsightResourceId: createAppInsights.outputs.resourceId
  }
  dependsOn: [
    logAnalytics
    appServicePlanLinux
    createAppInsights
  ]
}

This code will now create an a Windows App Service Plan with a Web App, a Linux App Service Plan with a Web App and also an Application Insights instance and hook up both web apps to the same App Insights instance for monitoring.
Yes this code could be tidied up even further but the purpose it so show you how easy it can be to deploy resources using Bicep along with the Azure Verified Modules github repository.

The post Deploy Azure Azure Web Apps Windows and Linux using Bicep! appeared first on Azure Greg.

When setting up your infrastructure in Azure, using the Azure Verified Modules can streamline the creation of any Azure Resource such as an Azure SQL Server, an Elastic Pool, and 2 demo databases. This post guides you through the code for doing just that, I leave it to you to create the parameters and fill them in

Bicep Code

//MARK: SQL Server
@description('SQL Server')
module sqlServer 'br/public:avm/res/sql/server:0.8.0' = if (deploySQLServer) {
  scope: resourceGroup("resourceGroupArray[4].name")
  name: 'sqlServer-${environmentName}'
  params: {
    name: sqlServerName
    administratorLogin: sqlAdministratorLogin
    administratorLoginPassword: keyVault.getSecret(config.kvSQLPassword)
    managedIdentities: {
      systemAssigned: false
      userAssignedResourceIds: [
        managedIdentity.id
      ]
    }
    primaryUserAssignedIdentityId: managedIdentity.id
    location: location
    tags: tags
    databases: [
      {
        name: 'demodb1'
        maxSizeBytes: 2147483648
        skuName: 'ElasticPool'
        skuTier: 'GeneralPurpose'
        zoneRedundant: false
        capacity: 0
        elasticPoolId: 'subscriptions/${subscriptionId}/resourceGroups/${resourceGroupArray[4].name}/providers/Microsoft.Sql/servers/${sqlServerName}/elasticpools/${elasticPoolName}'
      }
      {
        name: 'demodb2'
        maxSizeBytes: 2147483648
        skuName: 'ElasticPool'
        skuTier: 'GeneralPurpose'
        zoneRedundant: false
        capacity: 0
        elasticPoolId: 'subscriptions/${subscriptionId}/resourceGroups/${resourceGroupArray[4].name}/providers/Microsoft.Sql/servers/${sqlServerName}/elasticpools/${elasticPoolName}'
      }
    ]
    elasticPools: [
      {
        maxSizeBytes: 34359738368
        name: elasticPoolName
        perDatabaseSettings: {
            minCapacity: 0
            maxCapacity: 2
        }
        skuCapacity: 2
        skuName: 'GP_Gen5'
        skuTier: 'GeneralPurpose'
        zoneRedundant: false
        maintenanceConfigurationId: '/subscriptions/${subscriptionId}/providers/Microsoft.Maintenance/publicMaintenanceConfigurations/SQL_Default'
      }
    ]
  }
}

This code will now create an Azure SQL Server, an Elastic Pool and 2 demo databases within the Elastic Pool. Yes this code could be tidied up even further but the purpose it so show you how easy it can be to deploy resources using Bicep along with the Azure Verified Modules github repository.

The post Deploy Azure SQL Server, Database and Elastic pool in one go using Bicep! appeared first on Azure Greg.

In this episode, I was joined for a second time by Callum Linington - this time to discuss exceptions, which is quite fitting given the show’s name! We chatted about why you should avoid using exceptions for your main business logic and control flow, and explored better ways to handle errors. And I’m afraid the “monad” word got thrown in too! 🙈

For a full list of show notes, or to add comments - please see the website here