Healthchecks Should Not Be Pings

I had a long held belief that health checks should just be pings. “Is the websites up?” And for years, that was right. Not anymore.

Recently, a developer asked me if he should use health checks to ensure that the Entity Framework Cache stays in memory? It took me a while disassociate health checks from pings, but he was right. YES, you should use health checks to ensure the health of your site.

You should use health checks to do this:

• Ensure your site is up and running (ping)
• Ensure all cached values are available and, if possible, at the latest value.
• Ensure Entity Framework’s cache is hit before your first user
  • EF is a total hog of resources and complete slowdown on first hit
• Same thing for WCF
• Cache any application specific values needed before first hit

Health checks should not be pings. They should check the entire health of the site and its responsiveness. It should check the cache, it’s database connectivity, and everything that makes a website work. It’s a “health check” not a ping.

Tyk in Docker on Windows 10

I’m very new to all this technology so, please take this with a grain of salt. The reason I’m writing it is because I couldn’t find another guide that had end-to-end setup on Tyk in Docker on Windows 10.

Tyk is an API Gateway product that can be used to help manage a centralized location of many services/micro services. It is a product which is built on top of the nginx web server. And, nginx is really only supported as a “server” product on *nix based systems. Their Windows build is considered a beta.

So, there are already some good guides for each of the next steps, I’m just gonna pull them all together, and add one extra piece at the end.

Install Docker

There are a couple ways to get around the limitation of nginx only being “production ready on *nix”, but I choose to try out Tyk on Docker. Docker is the multiplatform container host that has created a lot of buzz within the cloud space. But, it also seems pretty awesome at setting up small containers on your local machine too.

Note: At this time, 2016-10-16, if you download a Docker for Windows installer, use the Beta Channel. The stable channel has a bug when trying to mount volumes into containers.

The docker installation wizard is pretty straight forward, so no worries there. Once, installed right-click on the Docker systray icon and select Open Kitematic …

A pop-up window should come up containing instructions on how to download and install Kitematic. It was amazingly simple and gave a nice GUI interface over the command line.

Follow Tyk’s Installer Instructions

Tyk provides instructions to setup the API gateway & dashboard with Docker on their website. I would suggest getting an account at Docker Hub. I don’t remember when in the process I created one, but I needed it to access … something.

In Step 2. Get the quick start compose files you’ll need to git clone the files to an folder under you C:\Users\XXXX folder. For me, Docker had a permissions restriction that only allowed containers to mount volumes from folders under my user folder. (So, that could be interesting if you run a container on a server under a service account.)

The silver lining about this set of containers is that they only need to use config files from your local drive. So, it’s not like your C:\Users folder is going to store a database.

In Step 4. Bootstrap your dashboard and portal, if you have bash available to you I would suggest trying it when you run ./setup.sh. I haven’t installed Win10 Anniversary Update, Git Bash, or Cygwin so I didn’t have bash available to run setup.sh.

However, I do feel somewhat comfortable in powershell, and the setup.sh script didn’t look too long. Below is the powershell conversion, which you should be saved in the same directory as setup.sh, and you should run .\setup.ps1 from the PowerShell ISE with the arguments that you want.

	#
	# This script will set up a full tyk environment on your machine
	# and also create a demo user for you with one command
	# USAGE
	# -----
	#
	# $> ./setup.sh {IP ADDRESS OF DOCKER VM}
	# OSX users will need to specify a virtual IP, linux users can use 127.0.0.1
	# Proxy
	$TYK_DASHBOARD_DOMAIN="tyk_dashboard"
	# Tyk dashboard settings
	$RANDOM = [Random]::new().Next()
	$TYK_DASHBOARD_USERNAME="test$RANDOM@test.com"
	$TYK_DASHBOARD_PASSWORD="test123"
	# Tyk portal settings
	$TYK_PORTAL_DOMAIN="www.tyk-portal-test.com"
	$TYK_PORTAL_PATH="/portal/"
	$DOCKER_IP="127.0.0.1"
	<#if($DOCKER_HOST) {
	Write-Host "Detected a Docker VM..."
	$REMTCP="$DOCKER_HOST#tcp://"
	$DOCKER_IP="$REMTCP%:*"
	}#>
	if($args[0]) {
	$DOCKER_IP=$args[0]
	Write-Host "Docker host address explicitly set."
	Write-Host "Using $DOCKER_IP as Tyk host address."
	}
	if($args[1]) {
	$TYK_PORTAL_DOMAIN=$args[1]
	Write-Host "Docker portal domain address explicitly set."
	Write-Host "Using $TYK_PORTAL_DOMAIN as Tyk host address."
	}
	if($args[0] -eq $null) {
	Write-Host "Using $DOCKER_IP as Tyk host address."
	Write-Host "If this is wrong, please specify the instance IP address (e.g. ./setup.sh 192.168.1.1)"
	}
	function Invoke-Docker([string] $UrlExt, [string] $Auth, [string] $Data, [switch] $Get, [switch] $Put) {
	$uri = "http://$($DOCKER_IP):3000/$UrlExt"
	$headers = New-Object 'System.Collections.Generic.Dictionary[[string],[string]]'
	if($Auth) { $headers.Add("authorization", $Auth); } else { $headers.Add("admin-auth", "12345"); }
	$headers.Add("Contenty-Type","application/json");
	if($Get) {
	$result = Invoke-WebRequest -Uri $uri -Method Get -Headers $headers
	} else {
	if($Put) {
	$result = Invoke-WebRequest -Uri $uri -Method Put -Headers $headers -Body $Data
	} else {
	$result = Invoke-WebRequest -Uri $uri -Method Post -Headers $headers -Body $Data
	}
	}
	if($result.StatusCode -ne 200) { throw "Error Calling $uri with `"$Data`".`nStatus Code = $($result.StatusCode)`nRawContent = $($result.RawContent)" }
	return $result.Content
	}
	Write-Host "Creating Organisation"
	$ORG_DATA = Invoke-Docker -UrlExt "admin/organisations" -Data '{"owner_name": "TestOrg5 Ltd.","owner_slug": "testorg", "cname_enabled":true}'
	$ORG_ID = (ConvertFrom-Json $ORG_DATA).Meta
	Write-Host "ORG ID: $ORG_ID"
	Write-Host "Adding new user"
	$USER_DATA = Invoke-Docker -UrlExt "admin/users" -Data "{`"first_name`": `"John`",`"last_name`": `"Smith`",`"email_address`": `"$TYK_DASHBOARD_USERNAME`",`"active`": true,`"org_id`": `"$ORG_ID`"}"
	$USER_AUTH = (ConvertFrom-Json $USER_DATA).Message
	$USER_LIST = Invoke-Docker -UrlExt "api/users" -Auth $USER_AUTH -Get
	$USER_ID = (ConvertFrom-Json $USER_LIST).Users[0].id
	Write-Host "USER AUTH: $USER_AUTH"
	Write-Host "USER ID: $USER_ID"
	Write-Host "Setting password"
	$OK = Invoke-Docker -UrlExt "api/users/$USER_ID/actions/reset" -Auth $USER_AUTH -Data "{`"new_password`":`"$TYK_DASHBOARD_PASSWORD`"}"
	Write-Host "Setting up the portal domain"
	$OK = Invoke-Docker -UrlExt "admin/organisations/$ORG_ID/generate-portals" -Data "domain=`"$TYK_PORTAL_DOMAIN`""
	Write-Host "Setting up the Portal catalogue"
	$CATALOGUE_DATA = Invoke-Docker -UrlExt "api/portal/catalogue" -Auth $USER_AUTH -Data "{`"org_id`": `"$ORG_ID`"}"
	$CATALOGUE_ID = (ConvertFrom-Json $CATALOGUE_DATA).Message
	$OK = Invoke-Docker -UrlExt "api/portal/catalogue" -Auth $USER_AUTH -Get
	Write-Host "Setting target URL for Portal APIs"
	$API_LIST = Invoke-Docker -UrlExt "api/apis" -Auth $USER_AUTH -Get
	$API_PORTAL_DATA = (ConvertFrom-Json $API_LIST).apis[2]
	$API_PORTAL_DATA.sort_by = 9; $API_PORTAL_DATA.api_definition.proxy.target_url = $API_PORTAL_DATA.api_definition.proxy.target_url.Replace("localhost", $TYK_DASHBOARD_DOMAIN);
	$API_PORTAL_DATA.api_definition.proxy.listen_path = $TYK_PORTAL_PATH;
	$API_PORTAL_ID = $API_PORTAL_DATA.api_definition.id;
	$API_PORTAL_API_DATA = (ConvertFrom-Json $API_LIST).Apis[1]
	$API_PORTAL_API_DATA.api_definition.proxy.target_url = $API_PORTAL_API_DATA.api_definition.proxy.target_url.Replace("localhost", $TYK_DASHBOARD_DOMAIN);
	$API_PORTAL_API_DATA.api_definition.proxy.listen_path = "/portal-api/";
	$API_PORTAL_API_ID = $API_PORTAL_API_DATA.api_definition.id;
	$API_PORTAL_ASSETS_DATA = (ConvertFrom-Json $API_LIST).Apis[0]
	$API_PORTAL_ASSETS_DATA.api_definition.proxy.target_url = $API_PORTAL_ASSETS_DATA.api_definition.proxy.target_url.Replace("localhost", $TYK_DASHBOARD_DOMAIN);
	$API_PORTAL_ASSETS_ID = $API_PORTAL_ASSETS_DATA.api_definition.id;
	$OK = Invoke-Docker -UrlExt "api/apis/$API_PORTAL_ID" -Auth $USER_AUTH -Data "$(ConvertTo-Json $API_PORTAL_DATA -Depth 999)" -Put
	$OK = Invoke-Docker -UrlExt "api/apis/$API_PORTAL_API_ID" -Auth $USER_AUTH -Data "$(ConvertTo-Json $API_PORTAL_API_DATA -Depth 999)" -Put
	$OK = Invoke-Docker -UrlExt "api/apis/$API_PORTAL_ASSETS_ID" -Auth $USER_AUTH -Data "$(ConvertTo-Json $API_PORTAL_ASSETS_DATA -Depth 999)" -Put
	Write-Host "Creating the Portal Home page"
	$OK = Invoke-Docker -UrlExt "api/portal/pages" -Auth $USER_AUTH -Data "{`"is_homepage`": true, `"template_name`":`"`", `"title`":`"Tyk Developer Portal`", `"slug`":`"home`", `"fields`": {`"JumboCTATitle`": `"Tyk Developer Portal`", `"SubHeading`": `"Sub Header`", `"JumboCTALink`": `"#cta`", `"JumboCTALinkTitle`": `"Your awesome APIs, hosted with Tyk!`", `"PanelOneContent`": `"Panel 1 content.`", `"PanelOneLink`": `"#panel1`", `"PanelOneLinkTitle`": `"Panel 1 Button`", `"PanelOneTitle`": `"Panel 1 Title`", `"PanelThereeContent`": `"`", `"PanelThreeContent`": `"Panel 3 content.`", `"PanelThreeLink`": `"#panel3`", `"PanelThreeLinkTitle`": `"Panel 3 Button`", `"PanelThreeTitle`": `"Panel 3 Title`", `"PanelTwoContent`": `"Panel 2 content.`", `"PanelTwoLink`": `"#panel2`", `"PanelTwoLinkTitle`": `"Panel 2 Button`", `"PanelTwoTitle`": `"Panel 2 Title`"}}"
	Write-Host ""
	Write-Host "DONE"
	Write-Host "===="
	Write-Host "Login at http://$($DOCKER_IP):3000/"
	Write-Host "Username: $TYK_DASHBOARD_USERNAME"
	Write-Host "Password: $TYK_DASHBOARD_PASSWORD"
	Write-Host "Portal: http://$TYK_PORTAL_DOMAIN$TYK_PORTAL_PATH"
	Write-Host ""

view raw setup.ps1 hosted with ❤ by GitHub

After that, I had a running Tyk API Gateway.

Other Thoughts

Since this was all new technology I ran into a lot of errors and read through a lot of issue/forum posts. Which makes me think this might not be the best idea for a production setup. If you’re able to make linux servers within your production environment, I would strongly suggest that.

Because I made so many mistakes I got used to these three commands which really helped recreate the environment whenever I messed things up. I hope this helps.

	docker stop $(docker ps -a -q) # stops all running containers in docker
	docker rm $(docker ps -a -q) # removes all containers in docker (I wanted to start clean each time)
	docker-compose up -d # recreates the environment (this is usually where errors happen)

view raw recreate-tykdocker.ps1 hosted with ❤ by GitHub

Get-FullDomainAccount

In a previous post I forgot to include the PowerShell code for Get-FullDomainAccount. Sorry about that.

Here it is:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

$env:USERDOMAIN = "<your domain>" <# .SYNOPSIS     Ensures that the given domain account also has the domain prefix. For example,     if the -DomainAccount is "IUSR_AbcXyz" the "<your domain>\IUSR_AbcXyz" would most likely     be returned. The domain is pulled from the current users domain, $env:USERDOMAIN.       If -Environment is provided, this will also run the -DomainAccount through     Get-EnvironmentDomainAccount to replace any environment specific information.   .LINK     Get-EnvironmentDomainAccount         Used to apply environment specific value to the domain account   .EXAMPLE     $result = Get-FullDomainAccount -DomainAccount "IUSR_AbcXyz"     $result -eq "<your domain>\IUSR_AbcXyz" #> Function Get-FullDomainAccount { [CmdletBinding()] Param (     [Parameter(Mandatory=$true)]     [string] $DomainAccount,     [string ]$Environment = "" )     $accountName = $DomainAccount;       if($Environment -ne "") {         $accountName = Get-EnvironmentDomainAccount -Environment $Environment -DomainAccount $DomainAccount;     }       if($accountName -match "ApplicationPoolIdentity") {         $accountName = "IIS AppPool\$accountName"     }       if($accountName -match "LocalSystem") {         $accountName = "$($env:COMPUTERNAME)\$accountName"     }       if($accountName -notmatch "\\") {         $accountName = $env:USERDOMAIN + "\" + $accountName;     }     return $accountName; }