One in ten people today live with a mental health disorder

Maya Health

mayahealth

How to Master .NET 8 Web API: From Setup to Security - The Best 50 Tips

কিভাবে .NET 8 ওয়েব এপিআই আয়ত্ত করবেন: সেটআপ থেকে নিরাপত্তা - সেরা 50 টি টিপস

.NET 8 Web API meistern: Von der Einrichtung bis zur Sicherheit – Die 50 besten Tipps

Cómo dominar la API web .NET 8: de la configuración a la seguridad: los 50 mejores consejos

Comment maîtriser l'API Web .NET 8 : de la configuration à la sécurité - Les 50 meilleurs conseils

.NET 8 वेब एपीआई में महारत कैसे हासिल करें: सेटअप से सुरक्षा तक - सर्वोत्तम 50 युक्तियाँ

.NET 8 Web API をマスターする方法: セットアップからセキュリティまで - ベスト 50 のヒント

.NET 8 Web API를 마스터하는 방법: 설정부터 보안까지 - 최고의 50가지 팁

Como dominar a API da Web .NET 8: da configuração à segurança - as 50 melhores dicas

Как освоить веб-API .NET 8: от настройки до безопасности — 50 лучших советов

.NET 8 Web API'sinde Uzmanlaşma: Kurulumdan Güvenliğe - En İyi 50 İpucu

Cách làm chủ API Web .NET 8: Từ thiết lập đến bảo mật - 50 mẹo hay nhất

如何掌握 .NET 8 Web API：从设置到安全 - 50 个最佳技巧

The use of technology in the healthcare industry increases, so it is more important than ever to concentrate on securing patient data. We almost don’t notice the amount of medical information we disclose. To our fitness trackers, to our phones, and to computer systems in hospitals. In this day and age, who would keep track of safe data privacy practices, right? Well, it’s definitely not right. Healthcare information security and patient data privacy should be at the top of the minds of software owners. Everything related to sensitive data: stored or transmitted digitally should be protected by law. But we all know law takes time to change and adjust to digital challenges. Not to mention that it’s different for regions, countries, and states. As a software developer, I’d like to offer a guide for privacy and security of health information to protect patient data privacy from unauthorized access, theft, and misuse. Cybersecurity Measures for Healthtech The healthcare industry is diverse and ranges from electronic health records to mHealth apps to medical devices. That’s why there isn’t one safe data privacy practice but a complex of them. The measures that are quite popular now are: Virtualization, encryption, and authentication Antivirus software and firewalls Intrusion detection systems (IDS), malware detection systems Cloud computing services/ blockchain technologies Data encryption at rest and in transit All of them are helpful when it comes to securing patient data. Let’s cover a few briefly and look at advantages and disadvantages. Data Encryption Encryption is the , so it can only be read by people who have permission to do so. Encryption protects data on devices such as laptops and smartphones by making it unreadable unless someone has the right key to decrypt it. process of encoding data That’s one of the ways of ensuring only medical professionals can have access to patient data. HIPPA regulations but recommend it. The benefit of such a method is that all patient records can be safely stored while authorized staff has the key for decryption. do not require data encryption The disadvantage is, ironically, the same key that can be lost or shared irresponsibly. That could lead to a data breach and expose sensitive information. Cloud Computing for Health Systems Most software nowadays is stored on the could. Such a decision is based on cost reduction and more convenient storage. Some healthcare providers are still hesitant to Without strategic movement, that’s for sure unwise. move patient care to digital spaces. However, clouds can make the healthcare industry more efficient and less expensive. Everyone is used to keeping medical histories in old-fashioned journals. That should be a relic of the past now as patients are looking for more convenient solutions. Like assessing their medical files from mobile devices. To do that, many medical providers should consider moving to the cloud. If the safety in the cloud is not enough, there are also blockchain technologies. To preserve and exchange patient data, . ledger technology is a reliable choice will bring forward “the monetization of health data through health data  marketplaces, the consumerization of  healthcare, and the growth of  metahealth.” Blockchain in healthcare according to predictions Blockchain-based systems and digital ledgers are the platforms to create protected healthcare applications. It’s not an emerging technology anymore, and with the right approach and trustable development team, it can be considered data protection best practice. Intrusion Detective Systems (IDS) No matter how proficient your software is, healthcare information security should be always considered vulnerable. Attackers might use malware to look for a vulnerability in your software or operating system. If they get access to patient records, the chance that you’ll fight them is slim to none. That’s why there are . They are built to detect or block malware if your antivirus or firewall missed them. Intrusion Detection Systems/Intrusion Prevent Systems (IDS/IPS) It’s highly unlikely, but even if hackers get into the health systems, IDS will notify, and the specialist will be able to remove them. Healthcare professionals need to consider such systems for securing patient data or health information exchanges. How to Prevent Data Breaches In Healthcare In healthcare, there are many factors that make data breaches more likely. The use of unencrypted devices, lack of cyber-security training for staff, and poor security measures are the factors that can contribute to a breach. In 2022, there were of more than 1 million records and a further 14 data breaches of over 500,000 records. The majority of those breaches were hacking incidents. 11 reported healthcare data breaches How do we make sure the software of an organization is safe against data breaches, theft, etc.? There is no single answer to that as there wouldn’t be a one-size-fits-all solution. to be up-to-date with increasing attacks on patient data privacy. Healthcare5 projects should comply with data protection best practices, laws, and regulations. Healthtech Projects require a joint strategy At least, it should be HIPPA, NIST, and ISO standards. Research the ones relevant to your country. It will save you fines as most healthcare standards are mandatory. And the second part of the strategy should be the best cybersecurity measures for your specific type of Healthtech project. Devices protections, passwords or two-factor authentication, data encryption, antivirus, IDS, third-party security software, and access controls. The list is endless, to be honest. If you develop an app or plan to increase cybersecurity in healthcare apps, contact an experienced software development team for help.

Technical Approaches to Keep Health Data Secure

The war in Ukraine, in the center of Europe, the country where I was born, taught me to not avoid risk-management. When you and your team develop a multi-million dollar business, you should always prepare different scenarios. No one knows what will happen to the global economy in reality, and which new “black swans” we will face. While being a CEO of , I want to be completely sincere and tell what is happening with DeHealth and where we are going today. DeHealth Let's start with the background of DeHealth. DeHealth (DEcentralized HEALTHcare) is a brand and international group of companies with headquarters in the UK and research centers across the globe, from the US to New Zealand, founded by Ukrainian and Israeli founders. Ukraine hosts one of DeHealth's R&D centers with a strong development team. The local sub-brand of DeHealth in Ukraine is the SaaS platform ASKEP. As of today, DeHealth is trusted by more than 35,000 doctors, 650 medical centers, and more than 3,200,000 patients from all over the world. It is also important to tell more about the solution and its components. DeHealth App, AI & Medical Data-Based Mobile App. For the App to work at full strength, it is necessary to collect, process, analyze, structure, and package individual health data into a finished product while using it to train the AI. Working with the medical data, which is the most sensitive, important and valuable asset in the healthcare industry, we prioritize the security of the data storage, respecting the Data Governance and Security Standards — Data Protection Law, GDPR, HIPAA, Data Protection Act. A high-quality cybersecurity of our product is guaranteed by our inside team and independent experts like Hacken and white hat hackers communities as well. decentralized storage for health data and digital assets, data oracles protocol, and incentive layer. The DHLT protocol digitizes and secures the global health data for everyone. The storage receives clinical, medical, and personal data on the health status of individuals (users) daily with its de-identification, structuring, and combination into a single network. uses all the data from the DHLT Network and provides users with an effective technological tool for affordable and preventive medicine, which makes the global healthcare industry more effective. DHLT Network: DeHealth AI The core is that underpins the DHLT Network, a decentralized storage for medical data and digital assets. With DHLT, anyone can upload and store their medical data, receive and host digital information, and sell their anonymized data. It is possible to use DHLT tokens to pay for services inside the DeHealth App and as an economic incentive to secure long-term storage of health data and its constant updating. DHLT, the native token What Happened? The native coin DHLT (Decentralized Health Token) allows DeHealth users to monetize their medical assets, thereby motivating them to engage in health as a new and high-quality lifestyle. As part of the IDO, the first issued “health tokens” from the DeHealth HLT Network were completely . sold out in 2 hours Further, when the token was listed on the exchange, we set the price of X5 (+500%) of the price of the private round. The listing on the exchange took place during the beginning of the Ukrainian-Russian war, which was used by our market maker, who took the liquidity of the project and tokens to his crypto-wallets during the first trading hours. Due to these illegal fraudulent activities, the price of the token has fallen. We consider this attack not only against our company but also against all our investors. Since March, there has been a criminal case registered under Art. 190 of the Criminal Code of Ukraine. We hired the best lawyers and specialists, including the Cyberpolice, to ensure that the scammers face charges. The war has shown the true faces of certain partners and contractors who, unfortunately, caused material and reputational damage to our company. At the same time, it mobilized us not to fall, but to make a big leap forward, despite the turbulence. Where We Are Today Thanks to the support of our technical partners and friendly launchpads, Cyberfi and Scaleswap, we have reissued the smart contract of the token and are already actively preparing to return to the exchange. We continue to follow our path to make this world a healthier and more honest place. We have partnered with Hacken, a global cybersecurity company, to make web3 healthcare even safer. We have already the audit from Hacken, which we disclosed separately. In addition, the DeHealth Foundation, together with our large international network of pharmaceutical companies, has been actively functioning for three months now. Together we help Ukraine with the supply of vital medicines. passed We started working together with the leading universities to create a powerful R&D for the digitalization of healthcare and the standardization of approaches to the safe donation of medical data. Furthermore, DeHealth continues active negotiations and partnerships not only with companies from the crypto industry but also with medical organizations and large pharmaceutical manufacturers. Big Pharma acts as a buyer of medical data for ensuring accuracy in the research and development of medicines. DeHealth acts as a provider of high-quality and relevant patient medical data, which helps top drug manufacturers make the medicine production more efficient, accurate, and effective. , a digital humanitarian, futurist, and innovator, KOL with 30 years of experience in specialty chemicals and pharmaceuticals at Novartis, Lonza, and Ciba, has joined our team to support these goals. Philippe Gerwill We are trying to make the world a safer and healthier place with our partners and friends. What is Next? My business partner Anna Bondarenko and I are constantly looking for resources, new talents for the team, and partners within the active business planning process that will help us succeed in the multi-billion dollar market. As the CEO, I am responsible for the company's growth and development. This is why I set a goal to attract VCs and family funds as our additional investors within 2-3 months. Our competitive advantages are web 3.0 at the intersection with a business model based on the big medical data of millions of people and its tokenization. Our focus remains on supporting the health of people around the world. With the help of a team of AI engineers in the USA, led by an ex-AI & Big Data developer at Google, we are building an effective tool for affordable and preventive medicine. Blockchain, on the other hand, allows organizing all medical data in the form of a special marketplace for safe digitalization, storage, and transfer to other participants in the healthcare industry. Thus, everyone can contribute to the global healthcare industry in the form of depersonalized medical data. DeHealth's emphasis is on collecting and structuring data, as well as on creating a decentralized infrastructure. Such an approach will make healthcare more effective while offering access to digital assets globally. DeHealth roadmap includes the launch of the MetaHealth metaverse as one of the priorities, which is the direction that the project team is already working on today. We, at DeHealth, do everything to ensure that our users, investors, and partners feel the stability of decentralized systems based on web 3.0. Our DeHealth community remains resilient and continues growing with a shared belief in the value of medical data, MedFi principles, and the power of MetaHealth. These values and beliefs show that DeHealth is the trend of the future originating in the modern day. In the context of the global crisis and falling markets, CEOs and founders of large global companies, as well as VCs, advise startups to set survival as their goal. Indeed, it is difficult to predict the global market’s behavior and its ability to recover tomorrow. In addition, these predictions are senseless. The one thing that I know for sure is that we are witnessing a new digital era, which is an exciting journey in web 3 and endless progress. Our goal is development and scaling in this new world. Thank you for growing and developing with us. Also published here .

Disrupting the Global Healthcare in Web3

Introduction The more I use Bicep, the more I love it. This is what ARM Templates should have been. When it comes to IaC, I usually use Terraform. It's the IaC tool we used at my last gig and I like that it has support for multiple clouds. However, I've recently changed jobs and I'm finding that I'm using ARM templates more. With this in mind, I've been wanting to learn Bicep and use it in my own personal projects so when the day comes that I have to convert ARM templates to Bicep code, I'll be prepared 😂 Coming back to this article, I'm working on a personal health application that has a bunch of APIs (Built using Azure Functions ⚡) that interacts with my data. Ideally, I'd like to integrate this within Azure API Management. I deploy these APIs using Azure DevOps so to be consistent, I want to deploy APIM using IaC via Azure DevOps. I'm going to show you how we can provision an Azure API Management instance using Bicep code and then deploy it using Azure DevOps. One thing to note before we get started is that of the time of writing, there are no officially supported tasks for Bicep in Azure DevOps. For Terraform and ARM templates, we can use tasks in DevOps to deploy our infrastructure. For this article, I've used some AZ CLI tasks to build and deploy my Bicep templates. So if you're reading this in a future where we can use officially supported Bicep tasks in DevOps, just keep this caveat in mind 😊 What is Bicep Lang? Bicep is a domain-specific language that uses declarative syntax to deploy Azure Resources. When we wrote ARM templates, we were essentially writing JSON to deploy resources to Azure. The syntax for this could get a little complex and for fancy stuff, we would need to write complicated expressions to get it working. Bicep Lang reduces that complexity significantly. Bicep is a transparent abstraction over ARM templates and when we deploy Bicep templates, it comes with a CLI that transpiles the Bicep file into ARM template JSON. As of v0.3, Bicep is supported by Microsoft and has 100% parity with ARM templates, meaning that you can start using it for production workloads! If you want to learn more about Bicep, you can check out the documentation here: https://docs.microsoft.com/en-us/azure/azure-resource-manager/bicep/ What is API Management API Management (APIM) allows us to create consistent API gateways for back-end services. Using APIM, we can publish APIs and make them available for external and internal developers to consume. APIM is made up of: which is the endpoint that accepts API calls and routes them to the right backend, verifies API Keys, enforces usage quotas and rate limits etc. The Gateway which allows to administer our API Program, define API schema, package APIs into products, set up policies etc. The Azure Portal which serves as the main web presence for developers, providing them with API documentation, allowing them to try out APIs via an interactive console and create an account that they can use to subscribe to APIs. The Developer Portal If you want to dive a bit deeper into APIM, check out the documentation: https://docs.microsoft.com/en-us/azure/api-management/ Writing our Bicep Code for API Management Let's start writing our Bicep code! 💪 The best tool for writing Bicep code is Visual Studio Code. There's also an awesome extension that you can download that will help validate your Bicep code and provide intellisense: https://github.com/Azure/bicep/blob/main/docs/installing.md#install-the-bicep-vs-code-extension For this tutorial, I'm not going to focus too much on the complicated aspects of APIM. I just want to provision a simple configuration to get started with. From what I can see from the docs, it looks like I'll need the following properties: (What the name of the APIM service will be) Name (The Type of resource we'll be provisioning) Type (The version of the ARM API that we will be using) ApiVersion (Properties of the APIM that we want to configure, mainly the Publisher Email and Name) Properties (where we will provision our APIM instance) Location (The SKU properties of our APIM instance) SKU You can see the full reference for the APIM template here: https://docs.microsoft.com/en-us/azure/templates/microsoft.apimanagement/2019-01-01/service?tabs=bicep With the above properties in mind, we can write the following Bicep code: param apimName string
param apimLocation string
param publisherName string
param publisherEmail string

resource myhealthapim 'Microsoft.ApiManagement/service@2019-12-01' = {
  name: apimName
  location: apimLocation
  sku: {
    name: 'Developer'
    capacity: 1
  }
  properties: {
    publisherEmail: publisherEmail
    publisherName: publisherName
  }
} As you can see, I've used some parameters for some of the configuration values for my APIM instance. Let's discuss what these are in Bicep. Using Parameters In Bicep, we can use parameters to provide information to our Bicep templates when we deploy them. This allows us to make our Bicep templates reusable. In the code above, we declared our parameters using the keyword. Here's an example: param param parameterName string param - indicates to Bicep that we are using a parameter parameterName - the name of our parameter string - refers to the type of the parameter We can provide parameters through files. Parameter files are created using JSON. If we are deploying resources to multiple environments, we can create a parameter file for each environment and provided different values depending on the environment. For this tutorial, I've created the following file. {
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "apimName": {
            "value": "myhealthapiportal"
        },
        "apimLocation": {
            "value": "australiaeast"
        },
        "publisherName": {
            "value": "MyHealth API Portal"
        },
        "publisherEmail": {
            "value": "willvelida@hotmail.co.uk"
        }
    }
} If you want to learn how parameters in Bicep, check out this Learn course: https://docs.microsoft.com/en-us/learn/modules/build-reusable-bicep-templates-parameters/2-understand-parameters Creating a Service Connection for Azure DevOps In order to deploy our Bicep template, we'll need a Service Connection in DevOps that's authorized to deploy resources to Azure. If you need to set this up, check out the following documentation: https://docs.microsoft.com/en-us/azure/devops/pipelines/library/service-endpoints?view=azure-devops&tabs=yaml#create-a-service-connection Creating and running our Release Pipeline Now that I have my Bicep template and parameter file, we can start to create our release pipeline. I've kinda shot myself in the foot here. I have a uber-repo that I use for all of my IaC code that I've written to deploy resources to Azure. So for this tutorial, I'll be using the classic Release pipeline rather than YAML. For this release, I used the following tasks: Let's go through each task. For our Copy Files task, I'm just copying the files from my GitHub artifact into the Default Working Directory on my build agent. We'll use files in our target directory to run Bicep commands from. Let's take a look at our first Azure CLI task: Here, we are running the following az cli command az bicep build --file "$env:SYSTEM_DEFAULTWORKINGDIRECTORY/main.bicep" Here, we are building our bicep file. We can do this to build the ARM template that would be created by the bicep file, which could be used to run automated tests against, or for adding it to template specification, which can be shared with other users in our team. To reference our Build file in the command, I'm using our System Default Working Directory as an environment. This is the folder that we copied our files to before. We can access variables in our release pipelines to transport and exchange data throughout our release pipelines: https://docs.microsoft.com/en-us/azure/devops/pipelines/release/variables?view=azure-devops&tabs=batch#default-variables Now let's move onto our final task, where we will be deploying our Bicep template: In this AZ CLI task, we're running the following commands az group create -l australiaeast -n myhealthapiportal-rg
az deployment group create --template-file "$env:SYSTEM_DEFAULTWORKINGDIRECTORY/main.bicep" --parameters "$env:SYSTEM_DEFAULTWORKINGDIRECTORY/main.parameters.json" --resource-group myhealthapiportal-rg In our first command, we're creating a resource group in Azure called myhealthapiportal-rg to deploy our APIM instance to. In our second command, we are creating a deployment at the subscription scope, using our main.bicep file as the template that we want to deploy and our main.parameters.json file as the parameters we will use for this deployment. I've also hard coded the resource group that I created earlier that I want to deploy our APIM resource to. With this all set up, we can now run our release pipeline and it should deploy our APIM instance to Azure Verifying that we deployed to Azure: This took me a lot of goes, mainly messing about with the AZ CLI commands and getting them to point at our files. Another thing to note is that I managed to deploy APIM the first time, but the deployment task took over an hour and failed, even though the deployment was successful when I went into my Azure portal. Want to learn more? Thanks for reading this article. At the time of writing, there are no official tasks for Bicep in Azure DevOps, so what I've done here to get this going is a bit of a hack, but it works. If you want to learn more about Bicep, I recommend checking out the following resources from Microsoft Learn: Introduction to infrastructure as code using Bicep: https://docs.microsoft.com/en-us/learn/modules/introduction-to-infrastructure-as-code-using-bicep/ Build your first Bicep template: https://docs.microsoft.com/en-us/learn/modules/deploy-azure-resources-by-using-bicep-templates/ Build reusable Bicep templates by using parameters: https://docs.microsoft.com/en-us/learn/modules/build-reusable-bicep-templates-parameters/ Hopefully you found this article useful! As always, if you have any questions, feel free to comment below or ask me on ! Twitter Happy Coding! 💻👨‍💻👩‍💻

How to Create an Azure API Management Instance using Bicep Lang via Azure DevOps

As part of my personal development, I've created a personal health platform that uses various different microservices (Built using Azure Functions) that extract data from my Fitbit account and store them in an Azure Cosmos DB database. I have other microservices that pass messages between different services via Azure Service Bus. For this project, I use Azure DevOps to build my artifacts, run my unit tests and deploy my microservices to Azure. The great thing about DevOps is that we can do all of this within the YAML pipeline. Yes I said YAML. Honestly, I don't know what the fuss is all about 😂 In a previous post, I talked about how we can deploy NuGet packages to a private feed in Azure Artifacts using YAML pipelines. If you haven't read that post yet, you can check it out below! https://dev.to/willvelida/publishing-nuget-packages-to-a-private-azure-artifacts-feed-with-yaml-build-files-3bnb In this article, we will turn our attention to building and deploying C# Azure Functions using a single build file. What we'll cover We've got quite a bit to cover, so I'll break down my YAML file and talk about each stage in the following order: Triggering a Build 👷‍♂️👷‍♀️ Using User-Defined Variables in our pipelines 👨‍🔬👩‍🔬 Defining Stages 💻 Building our project 🔨 Running our tests 🧪 Getting code coverage 🧾 Producing a Build Artifact 🏠 Using Secrets from Key Vault 🔑 Deploying our Function to Azure ⚡ Running our build pipeline 🚀 Triggering a Build 👷‍♂️👷‍♀️ In our build pipelines, we can use triggers to run our pipelines. We can use different types of triggers, ranging from triggering a build when we push our code to a defined branch, to . scheduled triggers based on a CRON schedule For this project, I'm just triggering my build every time I push to the main branch. To do so, I define this in my YAML file like so: trigger:
  - main Now if I wanted to do this properly, we could define multiple branch names to trigger builds from like so: trigger:
  - feature/*
  - bugfix/* This would trigger the builds when we push code to either our feature or bugfix branch. When we raise Pull Requests in DevOps, we can create policies on our PR to only be eligible to merge back into our main branch provided that the build was successful. This helps us increase our confidence that the code we are merging (and deploying) is of high quality, particularly if we are running tests as part of our build pipeline. To enable build validation on your branch policies, check out this documentation Using User-Defined Variables in our pipelines 👨‍🔬👩‍🔬 We can use user-defined variables in our YAML files to use throughout our pipeline. Doing this gives us the benefit of re-using common values across various stages and tasks in our pipeline, and it allows us to track changes to them over time using version control. We can define variables within out file with the following scope: , making it available to all jobs in our pipeline. At the root level , making it available to a specific stage in our pipeline. At the stage level , making it available to a specific job in our pipeline. At the job level In my case, I'm going to be re-using these variables throughout my pipeline, so I'm defining them at the root level. variables:
  buildConfiguration: 'Release'
  vmImageName: 'vs2017-win2016'
  functionAppName: 'famyhealthfitbitbody'
  azureSubscription: '<azureSubscription-id-or-name>'
  workingDirectory: '$(System.DefaultWorkingDirectory)/MyHealth.Fitbit.Body'
  projectName: 'MyHealth.Fitbit.Body' We're not just limited to user-defined variables in YAML pipelines! We can use System and Environment variables as well. To learn more about defining variables in YAML pipelines, check out this article Defining Stages 💻 Within our YAML pipelines, we can organize our jobs into Stages. These divide our pipeline into logical....well, stages that perform certain tasks, such as 'build the app', 'deploy to production'. In this example, I just have a stage and deploy stage. Every YAML pipeline has at least one stage even if we don't define it. As I have done in my file, we can also run stages depending on whether the previous stage has succeeded or not, like so: stages:
  - stage: Build
    displayName: Build Stage

    jobs:
      - job: Build
        displayName: Build MyHealth.Fitbit.Body
        pool:
          vmImage: $(vmImageName) Using YAML pipelines, we can define multiple stages of our pipeline and store it as code. Check out the if you want to learn more about how Stages work in YAML pipelines. documentation Building our project 🔨 Let's turn our attention to our Function. First up, I want to restore and build my .csproj files. In our YAML pipelines, we can se .NET Core tasks to run dotnet commands against our artifacts. To build my project, I'll and . restore build I'm using a custom NuGet feed hosted on Azure Artifacts, so I will need to point to this feed when restoring. For the build task, I want to build a release package, so I'll pass in the variable as an argument when running the command. buildConfiguration build For both commands, I'm going to point to all .csproj files in my repository. steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
   command: 'restore'
   feedsToUse: 'select'
   vstsFeed: '<feed-id>'
   projects: '**/*.csproj'
    
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
   command: 'build'
   projects: '**/*.csproj'
   arguments: --configuration $(buildConfiguration) Running our tests 🧪 Alongside my function code, I have a project for my Unit Tests. As part of my build, I want to run my unit tests to make sure that my changes haven't broken any of our tests and that they still pass. If any of my tests fail, I want the build to fail. To run our tests, we can use a .NET Core task that runs the command and point the task at our Unit Test .csproj file. test I also want to collect code coverage metrics with Coverlet. Coverlet is .NET tool that allows us to get unit test coverage for line, branch and method coverage. In our arguments parameters, I'm telling my task to run Coverlet to get the code coverage and then publish the test results to the */TestResults/Coverage folder on my build agent: - task: DotNetCoreCLI@2
  displayName: Run Unit Tests
  inputs:
   command: 'test'
   projects: '**/*UnitTests/*.csproj'
   arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
   publishTestResults: true Getting code coverage 🧾 Once we've generated our coverage report, we can publish it to see the results. I've got two tasks within my pipeline to achieve this. First, I'm using a bash script task to install the report generator onto the Build agent. Once that's installed, I'm creating the xml report into my TestResults/Coverage folder on the agent. We can also specify the report type that we want to generate, but for this tutorial I'm just generating an inline HTML report. If you want to use a task for this instead of running an inline script, you can try installing the following onto your DevOps organisation. task Once we have generated a report, I've got a second task that publishes the code coverage report. - script: |
    dotnet tool install -g dotnet-reportgenerator-globaltool
    reportgenerator -reports:$(Build.SourcesDirectory)/TestResults/Coverage/coverage.cobertura.xml -targetdir:$(Build.SourcesDirectory)/CodeCoverage -reporttypes:HtmlInline_AzurePipelines;Cobertura
    displayName: Create Code coverage report
  
- task: PublishCodeCoverageResults@1
  displayName: 'Publish Code Coverage'
  inputs:
    codeCoverageTool: Cobertura
    summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'
    reportDirectory: '$(Build.SourcesDirectory)/TestResults/Coverage/' When our build finishes, we can review our code coverage report within DevOps! It should look similar to this: Producing a Build Artifact 🏠 We've built our project and our tests pass! We now need to produce a build artifact that we will deploy as our Function. Starting with publish, all we need here is a .NET Core task that runs the command, publishes our project as a 'Release' package, zip it and then publish it to our Artifact Staging Directory on our build agent. publish We then use a to publish an artifact called 'drop' into our staging directory. Publish Build Artifact task - task: DotNetCoreCLI@2
  displayName: Publish
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --output $(build.artifactstagingdirectory)'
    zipAfterPublish: True
            
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)' Just a mini-recap before we move onto deployment. In our Build Stage we have: Built our .NET Projects Run our Unit Tests to ensure our build is a quality build Generate and publish a code test coverage report. Publish a build artifact to deploy to Azure. With that achieved, we are now ready to move onto our deployment stage! Deploying our Function Stage For our deployment stage, we'll need to create a new stage in our YAML file. In this case, I've added a and property to our Stage YAML block. In the YAML file, I'm saying that the 'Deploy' stage our 'Build' stage and that the 'Deploy' stage will only run on the condition that the 'Build' Stage has succeeded. condition dependsOn depends on - stage: Deploy
    displayName: 'Deploy MyHealth.Fitbit.Body'
    dependsOn: Build
    condition: succeeded()

    jobs:
      - deployment: Deploy
        displayName: Deploy MyHealth.Fitbit.Body
        environment: Production
        pool:
          vmImage: $(vmImageName) When we use multiple stages in a pipeline, they will run in the order that we define them in the YAML file. We can add dependencies to our stages using the parameter. dependsOn We can control which stages run by specifying the condition of that Stage. In my case, I'm stating that the 'Deploy' stage will only run provided that the 'Build' stage has run successfully. To learn more about how conditions work in YAML pipelines, check out the following . documentation Using Secrets from Key Vault 🔑 In my function, I'm doing performing a variety of tasks such as sending messages to Service Bus Queues and Topics, calling APIs using Access tokens etc. etc. In order to make these operations, I need to use connection strings and secrets that I'm storing in a Azure Key Vault. Because these are secrets and I don't want to expose them, I need to use a Azure Key Vault task within my pipeline. For this purpose, I can use the to download the secrets I need. Azure Key Vault task As a pre-requisite for this task, I need to create a that's linked to my Azure Subscription and I need a Key Vault that contains my secrets. Azure Resource Manager service connection Once I have this setup, I can use the following snippet in my pipeline: steps:
  - task: AzureKeyVault@1
    inputs:
      azureSubscription: '$(azureSubscription)'
      KeyVaultName: '<key-vault-name>'
      SecretsFilter: '*'
      RunAsPreJob: false Here, we are defining the subscription that contains our Key Vault with our secrets, and we are retrieving all of the secrets in our Key Vault. We could filter these out to use a comma-separated list of the secret names we want to download, but for now I'm just downloading everything. Deploying our Function to Azure ⚡ We're finally ready to deploy our Function! ⚡ For this I'm going to use a Azure App Service Deploy Task We can use this task to deploy a variety of different app service types, but in my YAML snippet, I'm specifying as our type. functionApp As a pre-req for this task, you'll need an App Service instance to deploy your code to. I'm also passing the package that we built earlier as our , using the variable for the name of our Function and then passing in key-values for our App Settings. I can pass in the secrets I need for my Function since we downloaded them in our Key Vault task. package $functionAppName - task: AzureRmWebAppDeployment@4
  displayName: 'Deploy Azure Function'
  inputs:
    azureSubscription: '$(azureSubscription)'
    appType: functionApp
    WebAppName: $(functionAppName)                   
    package: '$(Pipeline.Workspace)/drop/MyHealth.Fitbit.Body.zip'
    appSettings: '-FUNCTIONS_WORKER_RUNTIME "dotnet" -FUNCTIONS_EXTENSION_VERSION "~3" -KeyVaultName "<key-vault-name>" -AccessTokenName "<secret-name>" -ServiceBusConnectionString "$(<secret-value>)" -APPINSIGHTS_INSTRUMENTATIONKEY "<some-key>" -ExceptionQueue "myhealthexceptionqueue" -BodyTopic "myhealthbodytopic" -WEBSITE_TIME_ZONE "New Zealand Standard Time"'
    enableCustomDeployment: true
    RemoveAdditionalFilesFlag: true Our full YAML file Before we finish, here's my full YAML build pipeline: trigger:
  - main

variables:
  buildConfiguration: 'Release'
  vmImageName: 'vs2017-win2016'
  functionAppName: 'famyhealthfitbitbody'
  azureSubscription: '<azureSubscription-id-or-name>'
  workingDirectory: '$(System.DefaultWorkingDirectory)/MyHealth.Fitbit.Body'
  projectName: 'MyHealth.Fitbit.Body'

stages:
  - stage: Build
    displayName: Build Stage

    jobs:
      - job: Build
        displayName: Build MyHealth.Fitbit.Body
        pool:
          vmImage: $(vmImageName)
        
        steps:
          - task: DotNetCoreCLI@2
            displayName: Restore
            inputs:
              command: 'restore'
              feedsToUse: 'select'
              vstsFeed: '<artifact-feed-id>'
              projects: '**/*.csproj'
    
          - task: DotNetCoreCLI@2
            displayName: Build
            inputs:
              command: 'build'
              projects: '**/*.csproj'
              arguments: --configuration $(buildConfiguration)

          - task: DotNetCoreCLI@2
            displayName: Run Unit Tests
            inputs:
              command: 'test'
              projects: '**/*UnitTests/*.csproj'
              arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
              publishTestResults: true
  
          - script: |
              dotnet tool install -g dotnet-reportgenerator-globaltool
              reportgenerator -reports:$(Build.SourcesDirectory)/TestResults/Coverage/coverage.cobertura.xml -targetdir:$(Build.SourcesDirectory)/CodeCoverage -reporttypes:HtmlInline_AzurePipelines;Cobertura
            displayName: Create Code coverage report
  
          - task: PublishCodeCoverageResults@1
            displayName: 'Publish Code Coverage'
            inputs:
              codeCoverageTool: Cobertura
              summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'
              reportDirectory: '$(Build.SourcesDirectory)/TestResults/Coverage/'
    
          - task: DotNetCoreCLI@2
            displayName: Publish
            inputs:
              command: 'publish'
              publishWebProjects: false
              projects: '**/*.csproj'
              arguments: '--configuration $(buildConfiguration) --output $(build.artifactstagingdirectory)'
              zipAfterPublish: True
            
          - task: PublishBuildArtifacts@1
            displayName: 'Publish Artifact'
            inputs:
              PathtoPublish: '$(build.artifactstagingdirectory)'
  
  - stage: Deploy
    displayName: 'Deploy MyHealth.Fitbit.Body'
    dependsOn: Build
    condition: succeeded()

    jobs:
      - deployment: Deploy
        displayName: Deploy MyHealth.Fitbit.Body
        environment: Production
        pool:
          vmImage: $(vmImageName)

        strategy:
          runOnce:
            deploy:
              
              steps:
                - task: AzureKeyVault@1
                  inputs:
                    azureSubscription: '$(azureSubscription)'
                    KeyVaultName: '<key-vault-name>'
                    SecretsFilter: '*'
                    RunAsPreJob: false

                - task: AzureRmWebAppDeployment@4
                  displayName: 'Deploy Azure Function'
                  inputs:
                    azureSubscription: '$(azureSubscription)'
                    appType: functionApp
                    WebAppName: $(functionAppName)                   
                    package: '$(Pipeline.Workspace)/drop/MyHealth.Fitbit.Body.zip'
                    appSettings: '-FUNCTIONS_WORKER_RUNTIME "dotnet" -FUNCTIONS_EXTENSION_VERSION "~3" -KeyVaultName "<key-vault-name>" -AccessTokenName "<secret-name>" -ServiceBusConnectionString "$(<secret-value>)" -APPINSIGHTS_INSTRUMENTATIONKEY "<some-key>" -ExceptionQueue "myhealthexceptionqueue" -BodyTopic "myhealthbodytopic" -WEBSITE_TIME_ZONE "New Zealand Standard Time"'
                    enableCustomDeployment: true
                    RemoveAdditionalFilesFlag: true Running our build pipeline 🚀 We've successfully created a build pipeline in YAML that will be triggered every time we push to our branch. We can view the status of our build in Azure DevOps, which looks like this: main As you can see at the bottom of the image, we can see the result of each stage within our pipeline. If a particular stage had failed, we could use this to re-run a particular stage instead of having to push our code again to . main Wrapping Up Multi-Stage Build pipelines are awesome for defining our build and release process all within the same file. By using source control, we can track changes to our build process over time. We can also do useful things like generate and publish code coverage reports, download secrets from key vault and deploy apps all within one file! Hopefully, you found this article useful! As always, if you have any questions, feel free to comment below or ask me on ! Twitter Happy Coding! 💻👨‍💻👩‍💻 Also published on: https://dev.to/willvelida/building-and-deploying-c-azure-functions-using-multi-stage-pipelines-in-azure-devops-3ne9

How to Build and Deploy C# Azure Functions using Multi-Stage Pipelines in Azure DevOps

We can generate a refresh and access token required to call the Fitbit API programmatically with a simple Timer trigger function. As part of my personal project, I’m building my own personal health platform in Azure. I like to keep track of a variety of different health metrics, such as daily activity, food intake, and sleep patterns. To collect this data, I use a Fitbit Ionic. In the past, I used to download a monthly CSV file and just do some basic analysis on it. This was a bit tedious as I’d have to do some manual scrubbing of the data before doing anything with it. This took the time that I didn’t really want to waste, so I wanted to create a pipeline that just calls the Fitbit API to retrieve my data without having to manually clean the file myself. Using the Fitbit API is relatively straightforward. The challenging part can be ensuring that our refresh tokens and access tokens don’t expire on us. By default, these will expire after 8 hours. Thankfully, we can use an Azure Function Timer Trigger to request new access tokens and Azure Key Vault to store these tokens securely. This article will show you how to refresh your Access Tokens for the Fitbit API using Azure Functions and Key Vault. While this example focuses on the Fitbit API, you could apply this method to other API keys. How refresh tokens and access tokens work for the Fitbit API Fitbit uses OAuth 2.0 to authorize users and authenticate to the Fitbit API. The OAuth 2.0 framework needs our apps that call the Fitbit API to obtain an Access Token. This is used for making HTTPS requests to the API. Fitbit supports both Authorization Code Grant and Implicit Grant flows. For my project, I’m using the Authorization Code Grant flow. This is the recommended option for server-to-server communication using an application’s client secret. Using the Authorization Code Grant Flow, a user will consent to share their Fitbit data with an application with some or all of the scopes. When this consent is given, Fitbit will give us an authorization code as part of a callback URL. Our app will exchange this code for access and refresh tokens (the ones that we will store in Key Vault). By default, these tokens will expire. The refresh token is used to obtain access to new access and it refreshes the token. Refresh tokens can only be used once, so we need to store the new access token and refresh token pair in Key Vault when these are regenerated. If you want to learn how to set up an application in Fitbit, obtain a client id and client secret, and generate the authorization code to be able to generate refresh and access tokens, I highly recommend watching the below video (Shoutout to Franchyze923 for this ! Super helpful!) video Introducing our Function Once you’ve watched that video, you should have a client id, client secret, and a base64 encoded string of your client id and secret concatenated with the colon (Don’t know what I’m on about? Watch the video again 😉) We’ll need to store this in our Key Vault along with our Refresh Token that we generated earlier. Before we dive into the code, let’s take a look at what this Function is trying to do end-to-end. Check the following diagram: Every 6 hours, we want to start a process of refreshing our tokens. We could increase the frequency we refresh our tokens, but 6 hours is fine for my purpose. When we start the function, we want to make a call to the Fitbit API to refresh our tokens. To do this, I will need my existing refresh token as well as my Fitbit Credentials, which I have stored as secrets in Key Vault. Once we have these, we need to make a request to the Fitbit API using our tokens and credentials to generate new tokens. Once we have our tokens, we want to save them in Key Vault, so the next time we invoke our function to refresh our tokens again, we will use the updated values. Let’s dive into the code to make this clearer. Using HTTP Client to make our call To make calls to the Fitbit API, we can use the HttpClient library! In order to request a new refresh token, we need to make the following API call: POST https://api.fitbit.com/oauth2/token
Authorization: Basic Y2xpZW50X2lkOmNsaWVudCBzZWNyZXQ=
Content-Type: application/x-www-form-urlencoded

client_id=22942C&grant_type=authorization_code&redirect_uri=https%3A%2F%2Fexample.com%2Ffitbit_auth&code=<somecode> We can use the HttpClient library to build our POST request like so: using Microsoft.Extensions.Configuration;
using MyHealth.Auth.RefreshToken.Models;
using MyHealth.Common;
using Newtonsoft.Json;
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

namespace MyHealth.Auth.RefreshToken.Services
{
    public class RefreshTokenService : IRefreshTokenService
    {
        private readonly IConfiguration _configuration;
        private readonly IKeyVaultHelper _keyVaultHelper;
        private readonly HttpClient _httpClient;

        public RefreshTokenService(
            IConfiguration configuration,
            IKeyVaultHelper keyVaultHelper,
            HttpClient httpClient)
        {
            _configuration = configuration;
            _keyVaultHelper = keyVaultHelper;
            _httpClient = httpClient;
        }

        public async Task<RefreshTokenResponse> RefreshToken()
        {
            try
            {
                var fitbitRefreshTokenSecret = await _keyVaultHelper.RetrieveSecretFromKeyVaultAsync(_configuration["RefreshTokenName"]);
                var fitbitClientCredentials = await _keyVaultHelper.RetrieveSecretFromKeyVaultAsync(_configuration["FitbitCredentials"]);

                _httpClient.DefaultRequestHeaders.Clear();
                UriBuilder uri = new UriBuilder("https://api.fitbit.com/oauth2/token");
                uri.Query = $"grant_type=refresh_token&refresh_token={fitbitRefreshTokenSecret.Value}";
                var request = new HttpRequestMessage(HttpMethod.Post, uri.Uri);
                request.Content = new StringContent("");
                request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
                request.Headers.Authorization = new AuthenticationHeaderValue("Basic", fitbitClientCredentials.Value);

                var response = await _httpClient.SendAsync(request);
                response.EnsureSuccessStatusCode();

                var content = await response.Content.ReadAsStringAsync();
                var refreshTokenResponse = JsonConvert.DeserializeObject<RefreshTokenResponse>(content);

                return refreshTokenResponse;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
} In this class, we’re doing the following: Retrieving our existing Refresh Token and Fitbit Credentials from Key Vault. (I simplified these calls using a wrapper for the Key Vault C# SDK). Clearing our request headers, defining the URI we want to make the POST request to, and then defining query parameters as part of that URI. We need to use our Refresh Token here. Define the request as a POST request to our URI. Setting the Content to an empty string, setting the headers and content type to use ‘ ’ and setting our AuthorizationHeaderValue to use Basic authentication and passing in our Fitbit Credentials. application/x-www-form-urlencoded We then make our POST Request, ensure that it is successful and deserialize our response into a RefreshTokenResponse object before returning it. That RefreshTokenResponse is a custom class, I created so that I can use it as a return type. It’s defined as follows: using Newtonsoft.Json;

namespace MyHealth.Auth.RefreshToken.Models
{
    public class RefreshTokenResponse
    {
        [JsonProperty(PropertyName = "access_token")]
        public string AccessToken { get; set; }
        [JsonProperty(PropertyName = "expires_in")]
        public int ExpiresIn { get; set; }
        [JsonProperty(PropertyName = "refresh_token")]
        public string RefreshToken { get; set; }
        [JsonProperty(PropertyName = "scope")]
        public string Scope { get; set; }
        [JsonProperty(PropertyName = "token_type")]
        public string TokenType { get; set; }
        [JsonProperty(PropertyName = "user_id")]
        public string UserType { get; set; }
    }
} This class should help deserialize the following sample response into a strong type: {
  "access_token": "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0MzAzNDM3MzUsInNjb3BlcyI6Indwcm8gd2xvYyB3bnV0IHdzbGUgd3NldCB3aHIgd3dlaSB3YWN0IHdzb2MiLCJzdWIiOiJBQkNERUYiLCJhdWQiOiJJSktMTU4iLCJpc3MiOiJGaXRiaXQiLCJ0eXAiOiJhY2Nlc3NfdG9rZW4iLCJpYXQiOjE0MzAzNDAxMzV9.z0VHrIEzjsBnjiNMBey6wtu26yHTnSWz_qlqoEpUlpc",
  "expires_in": 3600,
  "refresh_token": "c643a63c072f0f05478e9d18b991db80ef6061e4f8e6c822d83fed53e5fafdd7",
  "token_type": "Bearer",
  "user_id": "26FWFL"
} Now that we have our new access token and refresh token, we can save them to Key Vault. Saving our secrets in Key Vault To save our refresh and access tokens, we can simply do the following: using Microsoft.Extensions.Configuration;
using MyHealth.Auth.RefreshToken.Models;
using MyHealth.Common;
using System;
using System.Threading.Tasks;

namespace MyHealth.Auth.RefreshToken.Services
{
    public class KeyVaultService : IKeyVaultService
    {
        private readonly IConfiguration _configuration;
        private readonly IKeyVaultHelper _keyVaultHelper;

        public KeyVaultService(
            IConfiguration configuration,
            IKeyVaultHelper keyVaultHelper)
        {
            _configuration = configuration;
            _keyVaultHelper = keyVaultHelper;
        }

        public async Task SaveTokensToKeyVault(RefreshTokenResponse refreshedTokens)
        {
            try
            {
                await _keyVaultHelper.SaveSecretToKeyVaultAsync(_configuration["RefreshTokenName"], refreshedTokens.RefreshToken);
                await _keyVaultHelper.SaveSecretToKeyVaultAsync(_configuration["AccessTokenName"], refreshedTokens.AccessToken);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
} Here I’m passing through our RefreshTokenResponse object I got earlier in my RefreshTokenService class and then saving the RefreshToken and AccessToken into Key Vault using the same wrapper from earlier. Complete Function end-to-end I’ve broken out these two components into their own classes. It might need some tidying up, but hopefully, the example is easy to follow. We can now inject these services into our Function like so: using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using MyHealth.Auth.RefreshToken.Models;
using MyHealth.Auth.RefreshToken.Services;
using MyHealth.Common;
using System;
using System.Threading.Tasks;

namespace MyHealth.Auth.RefreshToken.Functions
{
    public class RefreshAccessToken
    {
        private readonly IConfiguration _configuration;
        private readonly IRefreshTokenService _refreshTokenService;
        private readonly IKeyVaultService _keyVaultService;
        private readonly IServiceBusHelpers _serviceBusHelpers;

        public RefreshAccessToken(
            IConfiguration configuration,
            IRefreshTokenService refreshTokenService,
            IKeyVaultService keyVaultService,
            IServiceBusHelpers serviceBusHelpers)
        {
            _configuration = configuration;
            _refreshTokenService = refreshTokenService;
            _keyVaultService = keyVaultService;
            _serviceBusHelpers = serviceBusHelpers;
        }

        [FunctionName(nameof(RefreshAccessToken))]
        public async Task Run([TimerTrigger("0 0 */6 * * *")] TimerInfo myTimer, ILogger log)
        {
            try
            {
                log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

                log.LogInformation("Refreshing Fitbit Refresh and Access Token.");
                RefreshTokenResponse refreshTokenResponse = await _refreshTokenService.RefreshToken();

                log.LogInformation("Refresh and Access Token refreshed. Saving to Key Vault");
                await _keyVaultService.SaveTokensToKeyVault(refreshTokenResponse);
                log.LogInformation("Tokens saved to Key Vault.");
            }
            catch (Exception ex)
            {
                log.LogError($"Exception thrown in {nameof(RefreshAccessToken)}: {ex.Message}");
                await _serviceBusHelpers.SendMessageToQueue(_configuration["ExceptionQueue"], ex);
                throw ex;
            }
        }
    }
} Wrapping up Generating a new refresh token manually would be a pain. Thankfully with Azure Function timer triggers, we can generate tokens on a schedule. By storing the access token in Key Vault, we can retrieve the token when we need to make calls to the Fitbit API. While this example focuses on the Fitbit API, hopefully, you can apply this example to other services that require you to refresh your access token when needed. If you want to see the code repository for this sample, you can check it out . here Hopefully, you’ve enjoyed this article. If you have any questions or comments, please feel free to reach out to me on . Twitter Until next time, Happy coding! Previously published on . dev.to

How to Build Token Refresh Service for the Fitbit API in Azure

Introduction , we can publish NuGet packages to a private (or public) NuGet feed. These feeds can be scoped in Azure DevOps at either an organization level or at a project level. Using Azure Artifacts Creating a private NuGet feed in Azure DevOps is really simple. This article below shows have you can set one up. If you’re following along and you haven’t set up an internal feed yet, stop reading this article and check out the article . Once you’re done with that, you can return here. here This post will show you how to use a YAML build file to publish the NuGet packages we create to our own Private feeds in Azure Artifacts. Now you might have an opinion on YAML in general, and yes, we can achieve the same result via the Classic user interface. Still, I like being able to include our build files within our code repository and providing me with the ability to check the history of our build file using the git history of that YAML file. To publish our NuGet package to our internal feed, we need to do the following: Create our NuGet package. Decide our versioning strategy for our package. Publish our package to our Internal Feed. For this post, I will be using a helper library that I’ve been using for my own health application. If you want to look at it while reading this (it includes the YAML file), check it out . here Creating our NuGet Package Before jumping into the meat of our build file, We need to set some things up: trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  ProjectName: 'MyHealth.Common'
  ProjectPath: '**/MyHealth.Common.csproj'
  buildConfiguration: 'Release'

steps:
  - task: UseDotNet@2
    displayName: 'Install .NET Core SDK'
    inputs:
      packageType: 'sdk'
      version: '3.x'
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet restore'
    inputs:
      command: 'restore'
      projects: '$(ProjectPath)'
  
  - task: DotNetCoreCLI@2
    displayName: 'Build $(ProjectName)'
    inputs:
      command: 'build'
      arguments: '--configuration $(buildConfiguration)'
      projects: '$(ProjectPath)' Let’s break this down: We trigger the build to kick off every time we make a commit to our branch. main We set some common variables that we will need throughout our build pipeline. We’re using a Linux image as our build agent. We then install the .NET Core SDK on our build agent, restore our project using a task that runs the restore command, and build the project using another task that runs the build command. DotNetCoreCLI To create a NuGet package in our build file, we need to add a task like so: DotNetCoreCLI - task: DotNetCoreCLI@2
    displayName: 'Pack $(ProjectName)'
    inputs:
      command: 'pack'
      arguments: '--configuration $(buildConfiguration)'
      packagesToPack: '$(ProjectPath)'
      nobuild: true
      versioningScheme: 'off' In this task, we run the pack command and tell the task to pack our project path that I’ve defined earlier in the YAML file. I’ve set the argument to true since I’ve already built my project. nobuild My package is a .NET Standard package. For , Microsoft recommends that you use the tasks. If you’re building , you can use a task. .NET Core and .NET Standard packages DotNetCoreCLI packages for .NET Framework NuGet Versioning Strategy There are a couple of ways we can do this. In my package file, I’ve specified my Version number like so: .csproj <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
    <Description>Common Helper Library for MyHealth Applications</Description>
    <Authors>Will Velida</Authors>
    <Product>MyHealth</Product>
    <Version>1.4.0</Version>
    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Azure.Messaging.ServiceBus" Version="7.1.2" />
    <PackageReference Include="Azure.Storage.Blobs" Version="12.8.1" />
    <PackageReference Include="Microsoft.Azure.Cosmos.Table" Version="1.0.8" />
    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
  </ItemGroup>

</Project> If we wanted to achieve this via a build task defined in YAML, we could do so like this: variables:
  Major: '1'
  Minor: '0'
  Patch: '0'

steps:
- task: NuGetCommand@2
  inputs:
    command: pack
    versioningScheme: byPrereleaseNumber
    majorVersion: '$(Major)'
    minorVersion: '$(Minor)'
    patchVersion: '$(Patch)' With the task, we can use the semantic versioning scheme for our builds. However, once a version has been produced, we can’t update or replace that version. They are immutable. To produce new versions of our package each time we update them, we can do the following: NuGet Major.Minor.Patch Use the variable for the version number that we wish to increment. This will automatically increment the build number for that variable each time we push to our branch while keeping the other variables constant. $(rev:.r) Use the variable. This is ideal for creating prelease labels for the build while keeping our major, minor, and patch versions constant. $(date:yyyyMMdd) Publishing our package to the feed Now that we have a package, we can publish it in our feed. To publish to our Azure Artifacts feed, we’ll need to set the . Project Collection Build Service identity to be a Contributor on the feed Once we have enabled that, we can add the following YAML to our build pipeline: - task: NuGetAuthenticate@0

 - task: NuGetCommand@2
    displayName: 'Publish $(ProjectName)'
    inputs:
      command: push
      feedsToUse: 'select'
      packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg;!$(Build.ArtifactStagingDirectory)/**/*.symbols.nupkg'
      nuGetFeedType: 'internal'
      publishVstsFeed: '<projectname>/<feedname>'
      versioningScheme: 'off'
      allowPackageConflicts: true Here, we are using the command to authenticate our Build server to push packages to our internal NuGet feed. We then run a task with the push command to push our package (stored in our Artifact Staging Directory) to our internal NuGet feed. NuGetAuthenticate NuGetCommand Here, we have used as our VSTS feed to publish to. Remember, we can scope our feeds at either the project level or an organization level in Azure DevOps. Since my feed is scoped at the project level, I need to put the project name here. <projectname>/<feedname> I’ve also included the argument and stated that our target field is an internal feed. Since we are using the command in the NuGet command task, this argument is required. nuGetFeedType push Full YAML file Here’s our complete YAML file: trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  ProjectName: 'MyHealth.Common'
  ProjectPath: '**/MyHealth.Common.csproj'
  buildConfiguration: 'Release'

steps:
  - task: UseDotNet@2
    displayName: 'Install .NET Core SDK'
    inputs:
      packageType: 'sdk'
      version: '3.x'
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet restore'
    inputs:
      command: 'restore'
      projects: '$(ProjectPath)'
  
  - task: DotNetCoreCLI@2
    displayName: 'Build $(ProjectName)'
    inputs:
      command: 'build'
      arguments: '--configuration $(buildConfiguration)'
      projects: '$(ProjectPath)'

  - task: DotNetCoreCLI@2
    displayName: 'Pack $(ProjectName)'
    inputs:
      command: 'pack'
      arguments: '--configuration $(buildConfiguration)'
      packagesToPack: '$(ProjectPath)'
      nobuild: true
      versioningScheme: 'off'

  - task: NuGetAuthenticate@0

  - task: NuGetCommand@2
    displayName: 'Publish $(ProjectName)'
    inputs:
      command: push
      feedsToUse: 'select'
      packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg;!$(Build.ArtifactStagingDirectory)/**/*.symbols.nupkg'
      nuGetFeedType: 'internal'
      publishVstsFeed: 'projectname/feedname'
      versioningScheme: 'off'
      allowPackageConflicts: true Conclusion Hopefully, you can see how simple it is to publish our NuGet packages to a private NuGet feed in Azure Artifacts. This isn’t just limited to private NuGet feeds. We can also publish packages from DevOps to . NuGet.org If you want to learn more about Azure Artifacts, I recommend that you check out the that covers topics such as configuring feeds, publish NuGet (and other) types of packages, and more. documentation If you have any questions about this article, please let me know in the comments, or you can reach out to me on . Twitter Previously published on . dev.to

How to Publish NuGet Packages to a Private Feed Using Azure Artifacts

Today PHP is one of the most widely used programming languages in the world. Its popularity is attributable to some factors: most web platforms are already written in PHP, it’s fast and open-source, and there is a large PHP community to support it. PHP was initially made for web development, particularly for server-side programming of web applications. According to W2Techs, . The language resources and its particular qualities made PHP top-rated and much-in-demand service for hundreds of software development companies. about 80% of all websites have PHP backend To identify the 20 most prominent providers of PHP services, we used specific market research criteria and analyzed 500 web development companies. Among these criteria are PHP expertise, online reviews, market presence, geographic strategy, industry experience, and portfolio. A short description and key facts accompany every firm shortlisted for the rating. 1. Hidden Brains Founded in 2003, Hidden Brains is a software development company offering its services to more than 11 major business domains. The company has cooperated with clients from 102 countries. Hidden Brains provides dedicated development teams that use PHP for delivering online stores solutions, e-learning platforms, CRM, and enterprise portals. Ahmedabad, India Location: 250–999 Number of employees: McAfee, LSI, SanDisk, Raymond, Orange, Maxtor Key clients: Mobile App Development, Web Development, Artificial Intelligence Major service lines: Website: https://www.hiddenbrains.com/ 2. Daffodil Established in 1999, Daffodil is an IT company that offers web and mobile application development. The company delivers PHP product development for more than 12 main domains, including Ecommerce, Education, Healthcare, Social Networking, and other. Daffodil also helps its clients with PHP API development and team augmentation. Gurgaon, India Location: 250–999 Number of employees: Nokia, Lenskart, Lybrate, Sony Key clients: Custom Software Development, Mobile App Development, Web Development Major service lines: Website: https://www.daffodilsw.com/ 3. Seasia Infotech Since 2000, Seasia Infotech has been providing web and mobile application development. Today the company’s portfolio includes 2500+ completed projects. The company offers dedicated teams of PHP developers who deliver web applications, social media, ecommerce portals, and more. Among the company’s clients are The World Bank, The International Red Cross, and Flipkart. Mohali, India Location: 250–999 Number of employees: The World Bank, The International Red Cross, Flipkart Key clients: Web Development, Mobile App Development Major service lines: Website: https://www.seasiainfotech.com/ 4. HQSoftware Established in 2001, HQSoftware is a company that started as a PHP development firm. Today it has 76 professionals on board, who have already helped 300+ customers. The company provides the following PHP services: web application development, PHP software reengineering, and dedicated teams of PHP developers. Tallinn, Estonia Location: 50–249 Number of employees: Skoda, Bell, Sega, HTC, BBC, World Health Organization Key clients: IoT Development, Web Development Major service lines: Website: https://hqsoftwarelab.com/ 5. Vrinsoft Established in 2009, Vrinsoft is a custom software provider that has already helped more than 780 clients. By offering its dedicated development teams, the company serves more than seven countries globally. Vrinsoft delivers PHP development of a large number of software solutions, including CMS, DMS, online stores, and other. Glendale, CA Location: 50–249 Number of employees: Mitsubishi, DJI, Porsche, Myhealth1st, Flexipool, Apply Parking Key clients: Mobile App Development, Ecommerce Development, Web Development Major service lines: Website: https://www.vrinsofts.com/ 6. CDN Software Solutions Founded in 2000, CDN is a leading custom software development company in the USA with a team of 270+ professional developers. The company serves startups, enterprises, and medium-sized businesses. CDN provides PHP development of web applications, including ecommerce and financial platforms. The company also delivers testing services. Phoenix, AZ Location: 250–999 Number of employees: Toad Square Pty. Ltd, Agility Corp, WallTrot LLC Key clients: Custom Software Development, Mobile App Development Major service lines: Website: https://www.cdnsol.com/ 7. Iflexion Iflexion is a USA-based custom software development company that has helped more than 500 clients, among which are Philips, PayPal, Expedia, eBay, and other. The company delivers its services to 30+ countries and works with all of the major domains, including IT, Finance, Media, and Retail. By deploying PHP programming language, the company’s team of 850+ engineers develops websites, CMS and CRM, ecommerce platforms, social networks, and APIs. Denver, CO Location: 50–249 Number of employees: Philips, PayPal, Expedia, eBay, Cisco, Pepsi Key clients: Mobile App Development, Web Development Major service lines: Website: https://www.iflexion.com/ 8. Debut Infotech Established in 2011, Debut Infotech is a company that provides custom web and mobile app development. The company offers PHP development of various websites, from online stores to training platforms. Debut Infotech has been working with more than 160 clients, to whom it delivered more than 300 projects. Mohali, India Location: 10–49 Number of employees: HDFC Bank, KFC, Best Western Hotel, BlueScope Key clients: Mobile App Development, Web Development, Custom Software Development Major service lines: Website: https://www.debutinfotech.com/ 9. Nextware Technologies Established in 2006, Nextware Technologies is a software development company currently based in the USA. The company delivers consulting and development services for Finance, Healthcare, IT, Government, and more. Nextware Technologies offers such PHP-related services as PHP web development, dedicated development teams providing, and testing. Santa Monica, CA Location: 2–9 Number of employees: Landor, Lawrence Livermore National Laboratories, American Red Cross Key clients: Custom Software Development, Mobile App Development Major service lines: Website: http://www.nextwaretech.com/ 10. CMARIX Having delivered 1100+ web and 290+ mobile applications, CMARIX has helped dozens of clients from 46 countries all around the world. The company serves 12 industries, including Commerce, Real Estate, Finance, and Healthcare. CMARIX uses PHP for the development of custom websites, CMS, ecommerce platforms, social networks, and more. The company also provides its clients with team augmentation. Gujarat, India Location: 50–249 Number of employees: Schneider Electric, Swissmade, CapitalOne, Checkin Key clients: Web Development, Custom Software Development Major service lines: Website: https://www.cmarix.com/ 11. TechTIQ Solutions Headquartered in the UK, TechTIQ is a custom software provider of mobile/web applications. The company serves eight major business domains among which are Healthcare, Retail, and Commerce. TechTIQ offers dedicated teams that develop PHP-based CMS, online stores, social networks, e-learning platforms, and other various-purpose web applications. London, United Kingdom Location: 10–49 Number of employees: Imperial College London, University of Oxford, Wellclik, QuickPick Key clients: Mobile App Development, Custom Software Development Major service lines: Website: https://www.techtiq.co.uk/ 12. Consagous With three offices in the USA, UK, and India, Consagous is an IT service provider with 11 years of experience. The company delivers end-to-end mobile and web development. By using PHP, the company creates web solutions for a significant number of industries, including Healthcare, Automotive, Finance, Education, and Government. Austin, TX Location: 50–249 Number of employees: Clinic Fly, Desk Worm, Cargo Eye, Bra-voe Key clients: Custom Software Development, Mobile App Development, Wearable App Development Major service lines: Website: https://www.consagous.com/ 13. 247 Labs 297 Labs is a Toronto-based software company that delivers web/mobile applications and UI/UX design. The company unites certified PHP developers that specialize in Ecommerce solution creation. Some of the key clients of 247 Labs are such companies as Johnson & Johnson, General Motors, Motorola, Ontario Government, and other. Toronto, Canada Location: 10–49 Number of employees: General Motors, Motorola, Rogers Communications, Fido, Ontario Government Key clients: Web Development, Mobile App Development, Web Design Major service lines: Website: https://247labs.com/ 14. Codiant Headquartered in the USA, Codiant is a software development company that has three offices in Europe, Australia, and Asia. During eight years of work, Codiant has carried out more than 700 IT projects. Codiant provides PHP development of websites, mobile applications, ecommerce stores, and CMS and improves its solutions with MySQL, AJAX, and jQuery. East Moline, IL Location: 50–249 Number of employees: CareClix, SixTaxi, TaxiApp UK, Fantopias, Hoffr, Gandhistreet Key clients: Mobile App Development, Web Development, Blockchain Major service lines: Website: https://www.codiant.com/ 15. WebClues With 80 professionals aboard, WebClues is a custom software development company that delivers web/mobile app and UI/UX design development. It has already cooperated with 500 worldwide customers, among which are Dental Network, British Deco, Tryn Tryn, and other. WebClues offers PHP development of web applications for various industries, including Healthcare, Education, and Retail. Streetsboro, OH Location: 50–249 Number of employees: Laundrokart, Waterdrop, Tiledealer, Ecoaquaeurope Key clients: Mobile App Development, Web Development, Ecommerce Development Major service lines: Website: https://www.webcluesinfotech.com/ 16. Zealous System Founded in 2008, Zealous System is a company that provides full-cycle custom software development and has its offices in six countries all around the world. Zealous offers PHP consulting and development and provides software solutions for ecommerce websites, online booking/ticketing systems, e-learning platforms, live broadcasting applications, and more. Ahmedabad, India Location: 50–249 Number of employees: Not Revealed Key clients: Mobile App Development, Web Development, Custom Software Development Major service lines: Website: https://www.zealousys.com/ 17. iQlance Solutions iQlance is a Canadian company delivering a large number of software development solutions. Since 2011, the company has offered 1500+ projects and helped 200+ clients. iQlance provides full-cycle PHP development of CRM, ERP, enterprise portals, SCM, HRM, and EIS. The company also offers testing and support. Toronto, Canada Location: 10–49 Number of employees: String Flix, Career Builder, Buesor Key clients: Mobile App Development, Web Development Major service lines: Website: https://www.iqlance.com/ 18. Infigic Infigic is an IT outsourcing company that provides full-cycle web and mobile development. The company’s domain focus includes Ecommerce, Healthcare, and Consumer Services. Infigic employs PHP while creating software solutions for ecommerce platforms, social networks, CMS, payment gateways, automation tools, and more. Ahmedabad, India Location: 10–49 Number of employees: The Opal, Motocross World, RDB Concepts, Magtec Key clients: Mobile App Development, Ecommerce Development Major service lines: Website: https://www.infigic.com/ 19. Matellio Matellio is a California-based software design and development company delivering end-to-end web/mobile development. The company offers PHP development of various platforms for the following industries: Commerce, Education, Real Estate, Retail, Social Networking, Logistics, Healthcare, and more. When delivering its services, Matellio offers PHP dedicated development teams. San Jose, CA Location: 50–249 Number of employees: Hewlett Packard Enterprise, AirFusion, CardGlobal, Nervve, Brideside Key clients: Mobile App Development, Web Development Major service lines: Website: https://www.matellio.com/ 20. Onlinico Atlanta-based Onlinico is a software development services provider that has completed 37 projects. The company unites 34 IT professionals. While deploying PHP programming language, Onlinico offers custom web applications development and API development. The company also provides its customers with PHP dedicated development teams. Atlanta, GA Location: 10–49 Number of employees: Life4Me+, Crew, In-Depth, Redcapture Key clients: Custom Software Development, Mobile App Development, Web Development Major service lines: Website: https://www.onlini.co/

Top PHP Development Companies

We #MakeHealth Fest 2015 & The Nightscout Symposium THIS is the future of : healthcare https://www.youtube.com/watch?v=HyVaEASftF8 Healthcare that taps into the insights and wisdom of patients and caregivers, promotes creative solutions for healthcare, and scales innovation via a collaborative community. That’s why we are creating a Maker Movement for Health! We #MakeHealth Fest 2015 We held the 2nd annual We #MakeHealth Fest at the University of Michigan this fall and were fortunate to have the participation of a remarkable group of individuals passionate about making and health. Here are select videos from the event: Susannah Fox https://www.youtube.com/watch?v=JncBqNVwbuw&feature=youtu.be , Chief Technology Officer of the U.S. Department of Health and Human Services, spoke about her role within HHS, which is akin to a Chief Innovation Officer. She works with the , which uses methods like thinking and lean to bring innovation to the federal government. What was her since joining? Susannah Fox IDEA (innovation, design, entrepreneurship, action) lab design startup major insight “The opportunity that is being missed is the maker movement.” Susannah has a deep understanding of the maker movement given her background as an “internet geologist/ anthropologist” over the last decade, conducting fieldwork and research focused on the . Speaking to the makers in the audience, she said: health “hacking” done by patients and caregivers “If you can find the hackers, if you can find the artists, if you can find the people who make a way out of no way, then you are going to see the future. The work that you guys are doing is building the future. We need more ambassadors from the future to talk to establishment healthcare.” . Click here for the video of Susannah’s talk Jose Gomez-Marquez https://www.youtube.com/watch?v=GQkUA_sCrhg (TED Global Fellow) returned for the Fest for the 2nd year in a row (Check out his !), and described the mission of the : José Gómez-Márquez talk from the 2014 We #MakeHealth Fest MIT Little Devices Lab “How do you get more people to make stuff?” “How do you democratize medical device design and fabrication?” Jose talked about the importance of for health, which is design that is apparent, visible, and can be shared with a larger community. This transparency facilitates rapid and widespread modifications at scale, leading to improvements in design that can accelerate the pace of innovation. transparent design He contrasted this transparent design with the of most medical devices, which are completely shrouded in secrecy. black box design “We don’t understand them, they are definitely engineered so that we don’t understand them; the industrial design is housed in things that are not inviting for us to understand them…” What are the potential negative consequences of black box design? . Jose gave the example of modern-day farmers who are confronting . Previously, when the analog tractor broke down, farmers could do their own DIY repairs to fix them (farmers are the ultimate makers!). But with the new black box proprietary computer systems, they are locked out of accessing the “guts” of their own purchased equipment, they cannot do their own simple repairs, and they are forced to work with manufacturers who charge handsomely for repairs. For farmers who do decide to hack their own equipment, despite the fact that they own the equipment, hacking might be considered a crime based on the Digital Millennium Copyright Act (DMCA). (Watch the video to also learn about the DMCA for coffee.) Disenfranchisement of the user black box tractor technology Jose talked about potential inequities in access to healthcare tools and devices, as companies begin to charge more for their “secret” black box technology: a $2 thermometer that now sells for $29; a $14 blood pressure cuff that now sells for $170; and a 50 cent pill bottle now sells for $300. If you do a tear down of many of these devices there is nothing special that justifies the higher prices of some of these products, aside from the digitization and or the fact that they link up to your iPhone. From his perspective, makers can create many of these inventions at greater scale and much lower-cost. Disparities in Access. “Don’t give me a black box, give me a kit.” Jose ended his talk by sharing the lab’s important work focused on the to make medical device design more transparent and accessible (learn more about the here). “Making” empowers users (patients/caregivers, even healthcare providers) to hack, make, and modify medical designs; through the transparent sharing of these designs, there are opportunities for empowerment, greater scale, and sustainability. development of platforms and systems MEDIKits Click here for the video of Jose’s talk. Anna Young https://www.youtube.com/watch?v=UnefeSUDaNU , , also from the , described her work as co-Founder of , a program supported by the RWJ Foundation. She and her team have done extensive fieldwork in the area, demonstrating that nurses today and for most of the last century have been makers. MakerNurse conducted research at a number of healthcare institutions and found some remarkable maker nurses, including: Victor Ty, a radiation oncology nurse who created a to prepare and teach pediatric cancer patients about their treatments; Nicole Wooden, who created a contraption using a paper tray, a computer stand, and 3 pieces of acrylic from Home Depot to stabilize patients’ arms during catheter treatments; and Roxana Reyna, a wound care nurse in the neonatal intensive care unit, who was for inventing , reducing treatment time and the risk for infections. Anna Young TEDMED 2015 Speaker MIT Little Devices Lab MakerNurse Lego model of a linear accelerator recently honored at the White House Maker Faire a novel wound care method for omphalocele Both Anna and Jose are in the process of launching makerspaces for nurses in hospitals across the country to support a movement of “making” in healthcare. Learn more about ! their first makerspace here Click here for the video of Anna’s talk. George Albercook https://www.youtube.com/watch?v=tbGVIB77r5Q Watch the amazing work of . He is a local maker in Ann Arbor who has been working with a boy with cerebral palsy. Check out his amazing inventions, including: George Albercook A walker hack that stores energy using a spring. A contraption that makes physical therapy fun, using Minecraft, a makey makey, alligator clips, 2x4's, and 2 microphone stands. A wristband that gamifies the stretching tasks of physical therapy: he combined an to encourage the little boy stretch his arms, with that can record the angle between the forearm and upper arm to measure the stretching task, and added a bluetooth connection that communicates with a mobile phone, allowing him to earn points for his favorite games every time he accomplishes the task! engaging display a set of $3 accelerometers/gyroscopes Click here for the video of George’s talk. The Nightscout Symposium The Nightscout Project, Patient-driven Innovation, and the Maker Movement The next morning we held an academic symposium in conjunction with the University of Michigan Medical School and School of Information, featuring research (by myself and Liz Kaziunas (coming soon!)) and talks from community members from the , a DIY/maker mobile technology project that has led to incredible innovation within the diabetes community. Nightscout Project For the initial history of Nightscout watch featuring from our We #MakeHealth Fest in 2014. In his words, it was: this video John Costik “a little project I took on to make my son healthier, which took on a life of its own.” James Wedding https://www.youtube.com/watch?v=ytEh6kpp6xk is the President of the , who talked about his journey inside the Nightscout community and his work to help create the Foundation. James Wedding Nightscout Foundation As he says, “Necessity is the mother of invention. We do what we have to do. This is what I had to do. The foundation is where I could help out.” “It’s been an interesting dilemma to wrap a business model around something people do out of love.” Click here for the video of James’s talk. Ken Stack https://www.youtube.com/watch?v=EiNbB6HLNok Ken Stack talked about his work as a citizen hacker in the Nightscout community, building both diabetes software and hardware systems for his son. In his talk, he discusses what has been built by the community, including mobile displays, dashboard analysis and exploration/decision-making tools, hardware, and remote control and closed loop systems. Per Ken: “Nightscout was the most transformational experience we had in 10+ years in diabetes; there was nothing else that even came close. It has made all the difference.” Click here for the video of Ken’s talk. Weston Nordgren https://www.youtube.com/watch?v=YCUnsE7guQ8 is the Community Evangelist and a Nightscout Foundation Board member, who talks about how his family’s life was dramatically changed when they began using Nightscout. Weston Nordgren Wes stated: “We had received something back which had been taken from us.” As a result, he and his wife along with many others have espoused the philosophy of the community: “Pay it forward in any way that you can.” Individuals in the community are sharing code, providing 24–7 technical guidance and support on the Facebook group, convening local meetups to get people set up with the system, forming international Nightscout Facebook groups, and even ! creating memes Click here for the video of Wes’s talk. Nate Heintzman https://www.youtube.com/watch?v=Hb8uzCVQgzo Nate Heintzman, PhD, is the Senior Manager of Data Partnerships at Dexcom. Nate talked about his scientific and advocacy work in diabetes and how he is working with the Nightscout community to encourage collaboration between the lead users of the Nightscout community and medical device companies like Dexcom. (We are grateful to Nate and Dexcom for their generous support of our event!) Click here for the video of Nate’s talk. As you can see, the Maker Movement is already transforming healthcare. to reshape the future of healthcare. Join us I tweet and blog about health, technology, and participatory design as “ Doctor as Designer ”. Sign up for my Tinyletter here ! Click here for information about creative commons licensing. Additional links about our event can be found at our website, www.healthdesignby.us . My Disclosures: Google Life Sciences

Stories, News & Mentions about MAYAHEALTH

Mayahealth’s Stories on HackerNoon