Adding a private Docker registry to a PKS 1.5 Windows Kubernetes cluster

Pivotal Container Service (PKS) 1.5 and Kubernetes 1.14 bring *beta* support for Workers running Windows.  This means that we can provide the advantages of Kubernetes to a huge array of applications running on Windows.  I see this especially useful for Windows applications that you don’t have the source code for and/or do not want to invest in reworking it for .NET core or languages that run on Linux.

In nearly all cases, you’ll need an image with your applications’ dependencies or configuration and in the real world, we don’t want those in the public space like dockerhub.  Enter Private Docker Repositories.

PKS Enterprise includes VMware Harbor as a private registry, it’s very easy to deploy alongside PKS and provides a lot of important functionality.  The Harbor interface uses TLS/SSL; you may use a self-signed, enterprise PKI-signed or public CA-signed certificate.  If you chose to not use a public CA-signed certificate ($!), the self-signed or PKI-signed certificate must be trusted by the docker engine on each Kubernetes worker node.

Clusters based on Ubuntu Xenial Stemcells:

• The operator/administrator simply puts the CA certificate into the “Trusted Certificates” box of the Security section in Ops Manager.
• When BOSH creates the VMs for kubernetes clusters, the trusted certificates are added to the certificate store automatically.
• If using an enterprise PKI where all of the internal certificates are signed by the Enterprise CA, this method makes it very easy to trust and “un-trust” CAs.

Clusters based on Windows 2019 Stemcells:

This is one of those tasks that is easier to perform on Linux that it is on Windows.  Unfortunately, Windows does not automatically add the Trusted Certificates from Ops Manager to the certificate store, so extra steps are required.

1. 1. Obtain the Registry CA Certificate.  In Harbor, you may click the “REGISTRY CERTIFICATE” link while in a Project.  Save the certificate to where the BOSH cli is installed (Ops Manager typically).
   2.  Connect BOSH cli to director.  This may be done on the Ops Manager.
   3. List BOSH-managed vms to identify the service_instance deployment corresponding to the targeted K8s cluster by matching the VM IP address to the IP address of the master node as reported by PKS cluster.
   4. Run this command to copy the certificate to the Windows worker

      bosh -e ENV -d DEPLOYMENT scp root.cer WINDOWS-WORKER:/

      • ENV – your environment alias in the BOSH cli
      • DEPLOYMENT – the BOSH deployment that corresponds to the k8s cluster; ex: service-instance_921bd35d-c46d-4e7a-a289-b577ff743e15
      • WINDOWS-WORKER – the instance name of the specific Windows worker VM; ex: windows-worker/277536dd-a7e6-446b-acf7-97770be18144

      This command copies the local file named root.cer to the root folder on the Windows VM

   5. Use BOSH to SSH into the Windows Worker.

      bosh -e ENV -d DEPLOYMENT ssh WINDOWS-WORKER

      • ENV – your environment alias in the BOSH cli
      • DEPLOYMENT – the BOSH deployment that corresponds to the k8s cluster; ex: service-instance_921bd35d-c46d-4e7a-a289-b577ff743e15
      • WINDOWS-WORKER – the instance name of the specific Windows worker VM; ex: windows-worker/277536dd-a7e6-446b-acf7-97770be18144

      

      SSH into Windows node, notice root.cer on the filesystem

   6. In the Windows SSH session run “powershell.exe” to enter powershell
   7. At the PS prompt, enter

      Import-certificate -filepath .\root.cer -CertStoreLocation 
      Cert:\LocalMachine\Root

      The example above imports the local file “root.cer” into the Trusted Root Certificate Store
      

   8. Type “exit” twice to exit PS and SSH
   9. Repeat steps 5-8 for each worker node.

Add docker-registry secret to k8s cluster

Whether the k8s cluster is running Windows workers or not, you’ll want to add credentials for authenticating to harbor.  These credentials are stored in a secret. To add the secret, use this command:

kubectl create secret docker-registry harbor \
--docker-server=HARBOR_FQDN \
--docker-username=HARBOR_USER \
--docker-password=USER_PASS \
--docker-email=USER_EMAIL

• HARBOR_FQDN – FQDN for local/private Harbor registry
• HARBOR_USER – name of user in Harbor with access to project and repos containing the desired images
• USER_PASS – username for the above account
• USER_EMAIL – email adddress for the above account

Note that this secret is namespaced; it needs to be added to the namespace of the deployments that will reference it

More info

Here’s an example deployment yaml for a Windows K8s cluster that uses a local private docker registry.  Note that Windows clusters cannot leverage NSX-T yet, so this example uses a NodePort to expose the service.

Logging into a Kubernetes cluster with an OIDC LDAP account

I confess, most of my experience with Kubernetes is with Pivotal Container Service (PKS) Enterprise.  PKS makes it rather easy to get started and I found that I took some tasks for granted.

In PKS Enterprise, one can use the pks cli to not only life-cycle clusters, but to obtain the credentials to the cluster and automatically update the kubeconfig with the account information.  So, administrative/operations users can run the command “pks get-credentials my-cluster” to have a kubeconfig updated with the authentication tokens and parameters to connect to my-cluster.

K8s OIDC using UAA on PKS

The PKS controller includes the User Account and Authentication (UAA) component, which is used to authenticate users into PKS Enterprise.  UAA can also be easily configured to connect to an existing LDAP service – this is the desired configuration in most organizations so that users account exist in one place (Active Directory in my example).

So, I found myself wondering “I don’t want to provide the PKS CLI to developers, so how can they connect kubectl to the cluster?”

Assumptions:

• PKS Enterprise on vSphere (with or without NSX-T)
• Active Directory
• Developer user account belongs to the k8s-devs security group in AD

Prerequisite configuration:

1. UAA on PKS configured a with UAA User Account Store: LDAP Server.  This links UAA to LDAP/Active Directory
2. User Search Filter: userPrincipalName={0}  This means that users can login as user@domain.tld
3. Group Search Filter: member={0} This ensures that AD groups may be used rather than specifying individual users
4. Configure created clusters to use UAA as the OIDC provider: Enabled  This pre-configures the kubernetes API to use OpenID Connect with UAA. If not using PKS Enterprise, you’ll need to provide another OpenID Connect-Compliant endpoint (like Dex), link it to Active Directory and update the kubernetes cluster api manually to use the OpenID Authentication.

 

Operator: Create Role and RoleBinding:

While authentication is handled by OIDC/UAA/LDAP, Authorization must be configured on the cluster to provide access to resources via RBAC.  This is done by defining a Role (or clusterRole) that indicates what actions may be taken on what resources and a RoleBinding which links the Role to one or more “subjects”.

1.  Authenticate to kubernetes cluster with an administrative account (for example, using PKS cli to connect)
2.  Create yaml file for our Role and RoleBinding:

   kind: Role
   apiVersion: rbac.authorization.k8s.io/v1
   metadata:
     name: developers
   rules:
   - apiGroups: ["", "extensions", "apps"]
     resources: ["deployments", "replicasets", "pods"]
     verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] 
     # You can also use ["*"]
   ---
   kind: RoleBinding
   apiVersion: rbac.authorization.k8s.io/v1beta1
   metadata:
     name: developer-dev-binding
   subjects:
   - kind: Group
     name: k8s-devs
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: developers
     apiGroup: rbac.authorization.k8s.io
   

   In the example above, we’re creating a Role named “developers”, granting access to the core, extensions and apps API groups and several actions against deployments, replicaSets and pods. Notice that developers in this role would have have access to secrets (for example)
   The example RoleBinding binds a group named “k8s-devs” to the developers role. Notice that we have not created the k8s-devs group in Kubernetes or UAA; it exists in Active Directory

3. Use Kubectl to apply the yaml, creating the Role and Rolebinding in the targeted namespace

 

Creating the kubeconfig – the hard way

To get our developer connected with kubectl, they’ll need a kubeconfig with the authentication and connection details.  The Hard way steps are:

1. Operator obtains the cluster’s certificate authority data.  This can be done via curl or by copying the value from the existing kubeconfig.
2. Operator creates a template kubeconfig, replacing the value specified, then sends it to the developer user

   apiVersion: v1
   clusters:
   - cluster:
     certificate-authority-data: <OBTAINED IN STEP 1 >
     server: < FQDN to Master Node. >
     name: PROVIDED-BY-ADMIN
   contexts:
   - context:
       cluster: PROVIDED-BY-ADMIN
       user: PROVIDED-BY-USER
     name:  PROVIDED-BY-ADMIN
   current-context: PROVIDED-BY-ADMIN
   kind: Config
   preferences: {}
   users:
   - name: PROVIDED-BY-USER
     user:
       auth-provider:
         config:
           client-id: pks_cluster_client
           cluster_client_secret: ""
           id-token: PROVIDED-BY-USER
           idp-issuer-url: https://PROVIDED-BY-ADMIN:8443/oauth/token
           refresh-token:  PROVIDED-BY-USER
         name: oidc

3. The developer user obtains the id_token and refresh_token from UAA, via a curl command
   curl 'https://PKS-API:8443/oauth/token' -k -XPOST -H
'Accept: application/json' -d "client_id=pks_cluster_client&client_secret=""&grant_type=password&username=UAA-USERNAME&response_type=id_token" --data-urlencode password=UAA-PASSWORD
4. The developer user updates the kubeconfig with the id_token and refresh token in the kubeconfig

 

Creating the kubeconfig – the easy way

Assuming the developer is using Mac or Linux…

1. Install jq on developer workstation
2. Download the get-pks-k8s-config.sh script, make it executable (chmod +x get-pks.k8s.config.sh)
3. Execute the script (replace the params with your own)

   ./get-pks-k8s-config.sh --API=api.pks.mydomain.com \
   --CLUSTER=cl1.pks.mydomain.com \
   --USER=dev1@mydomain.com \
   --NS=scratch

   • API – FQDN to PKS Controller, for UAA
   • CLUSTER – FQDN to master node of k8s cluster
   • USER – userPrincipalName for the user
   • NS – Namespace to target; optional
4. After entering the user’s password, the script will set the params in the kubeconfig and switch context automatically

Try it out
Our developer user should able to “see” pods but not namespaces for example:

dev1 can see pods but not namespaces

 

Creating the kubeconfig – the easiest way

1. Provide the developer with the PKS CLI tool, remember we have not added them to any group or role with PKS admin permissions.
2. Provide the developer with the PKS API endpoint FQDN and the cluster name
3. The developer may run this command to generate the updated kubeconfig and set the current context
   pks get-kubeconfig CLUSTERNAME -a API -u USER -k
   • CLUSTERNAME is the name of the cluster
   • API – FQDN to PKS Controller
   • USER – userPrincipalName for the user
4. You’ll be prompted for the account password. Once entered, the tool will fetch the user-specific kubeconfig.

Use PKS CLI to get the kubeconfig

 

Using Helm and Dynamic PersistentVolumes with Multi-AZ PKS on vSphere

So, you’ve installed PKS and created a PKS cluster.  Excellent!  Now what?

We want to use helm charts to deploy applications.  Many of the charts use PersistentVolumes, so getting PVs set up is our first step.

There are a couple of complicating factors to be aware of when it comes to PVs in a multi-AZ/multi-vSphere-Cluster environment.  First, you probably have cluster-specific datastores – particularly if you are using Pivotal Ready Architecture and VSAN.  These datastores are not suitable for PersistentVolumes consumed by applications deployed to our Kubernetes cluster.  To work-around this, we’ll need to provide some shared block storage to each host in each cluster.  Probably the simplest way to do this is with an NFS share.

Prerequisites:

Common datastore; NFS share or iSCSI

In production, you’ll want a production-quality fault-tolerant solution for NFS or iSCSI, like Dell EMC Isilon. For this proof-of-concept, I’m going to use an existing NFS server, create a volume and share it to the hosts in the three vSphere clusters where the PKS workload VMs will run.  In this case, the NFS datastore is named “sharednfs” ’cause I’m creative like that.  Make sure that your hosts have adequate permissions to the share.  Using VMFS on iSCSI is supported, just be aware that you may need to cable-up additional NICs if yours are already consumed by N-VDS and/or VSAN.

Workstation Prep

We’ll need a handful of command-line tools, so make sure your workstation has the PKS CLI and Kubectl CLI from Pivotal and you’ve downloaded and extracted Helm.

PKS Cluster
We’ll want to provision a cluster using the PKS CLI tool.  This document assumes that your cluster was provisioned successfully, but nothing else has been done to it.  For my environment, I configured the “medium” plan to use 3 Masters and 3 Workers in all three AZs, then created the cluster with the command

pks create-cluster pks1cl1 --external-hostname cl1.pks1.lab13.myenv.lab --plan "medium" --num-nodes "3"

Logged-in
Make sure you’re logged into the Kubernetes cluster. In PKS, the easiest way to do this is via the PKS cli:

pks login -a api.pks1.lab13.myenv.lab -u pksadmin -p my_password --skip-ssl-validation
pks cluster pks1cl1
pks get-credentials pks1cl1
kubectl config use-context pks1cl1
kubectl get nodes -o wide

Where “pks1cl1″ is replaced by your cluster’s name,”api.pks1.lab13.myenv.lab” is replaced by the FQDN to your PKS API server, “pksadmin” is replaced by the username with admin rights to PKS and “my_password” is replaced with that account’s password.

Procedure:

1. Create storageclass
   • Create storageclass spec yaml. Note that the file is named storageclass-nfs.yml and we’re naming the storage class itself “nfs”:

     kind: StorageClass
     apiVersion: storage.k8s.io/v1
     metadata:
       name: nfs
       annotations:
         storageclass.kubernetes.io/is-default-class: "true"
     provisioner: kubernetes.io/vsphere-volume
     parameters:
       diskformat: thin
       datastore: sharednfs
       fstype: ext3
     

     

   • Apply the yml with kubectl
     

     kubectl create -f storageclass-nfs.yml

     

   • Create a sample PVC (Persistent Volume Claim). Note that the file is names pvc-sample.yml, the PVC name is “pvc-sample” and uses the “nfs” storageclass we created above. This step is not absolutely necessary, but will help confirm we can use the storage.

     kind: PersistentVolumeClaim
     apiVersion: v1
     metadata:
       name: pvc-sample
       annotations:
         volume.beta.kubernetes.io/storage-class: nfs
     spec:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: 1Gi
       storageClassName: nfs
     

   • Apply the yml with kubectl
     

     kubectl create -f pvc-sample.yml

     
     If you’re watching vSphere closely, you’ll see a VMDK created in the kubevols folder of the NFS datastore

   • Check that the PVC was created with
     

     kubectl get pvc

     and

     kubectl describe pvc pvc-sample

     

   • Remove sample PVC with
     

     kubectl delete -f pvc-sample

2. Configure Helm and Tiller
   • Create Service Account for tiller with

     apiVersion: v1
     kind: ServiceAccount
     metadata:
       name: tiller
       namespace: kube-system
     ---
     apiVersion: rbac.authorization.k8s.io/v1beta1
     kind: ClusterRoleBinding
     metadata:
       name: tiller
     roleRef:
       apiGroup: rbac.authorization.k8s.io
       kind: ClusterRole
       name: cluster-admin
     subjects:
       - kind: ServiceAccount
         name: tiller
         namespace: kube-system
     

   • Apply the service account yml with Kubectl
     

     kubectl create -f rbac-config.yml

     

   • Initialize helm and tiller with
     

     helm init --service-account tiller

     

   • Check that tiller is ready
     

     helm version

     
     Look for a version number for the version; note that it might take a few seconds for tiller in the cluster to get ready.

3. Deploy sample helm chart
   • Update helm local chart repository. We do this so that we can be sure that helm can reach the public repo and to cache teh latest information to our local repo.
     

     helm repo update

     
     If this step results in a certificate error, you may have to add the cert to the trusted certificates on the workstation.

   • Install helm chart with ingress enabled. Here, I’ve selected the Dokuwiki app. The command below will enable ingress, so we can access it via routable IP and it will use the default storageclass we configured earlier.
     

     helm install --name dokuwiki \
--set ingress.enabled="true",dokuwikiUsername=admin,dokuwikiPassword=password \
stable/dokuwiki

     Edit – April 23 2019 – Passing the credentials in here makes connecting easier later.

   • Confirm that the app was deployed

     helm list
     kubectl get pods -n default
     kubectl get services -n default

     
     From the get services results, make a note of the external IP address – in the example above, it’s 192.13.6.73

   • Point a browser at the external address from the previous step and marvel at your success in deploying Dokuwiki via helm to Kubernetes!
     If you want to actually login to your Dokuwiki instance, first obtain the password for the user account with this command:

     kubectl get secret -n default dokuwiki-dokuwiki \
     -o jsonpath="{.data.dockuwiki-password}" | base64 --decode

     Then login with username “user” and that password.

      

     Edit – 04/23/19 – Login with the username and password you included in the helm install command

4. Additional info
   • View Persistent Volume Claims with
     

     kubectl get pvc -n default

     
     This will list the PVCs and the volumes in the “default” namespace. Note the volume corresponds to the name of the VMDK on the datastore.

   • Load-Balancer
     Notice that since we are leveraging the NSX-T Container Networking Interface and enabled the ingress when we installed dokuwiki, a load-balancer in NSX-T was automatically created for us to point to the application.

This took me some time to figure out; had to weed through a lot of documentation – some of which contradicted itself and quite a bit of trial-and-error. I hope this helps save someone time later!

Automating PKS Upgrades

Last night, Pivotal announced new versions of PKS and Harbor, so I thought it’s time to simplify the upgrade process. Here is a concourse pipeline that essentially aggregates the upgrade-tile pipeline so that PKS and Harbor are upgraded in one go.

What it does:

1. Runs on a schedule – you set the time and days it may run
2. Downloads the latest version of PKS and Harbor from Pivnet- you set the major.minor version range
3. Uploads the PKS and Harbor releases to your BOSH director
4. Determines whether the new release is missing a stemcell, downloads it from PivNet and uploads it to BOSH director
5. Stages the tiles/releases
6. Applies changes

What you need:

1. A working Concourse instance that is able to reach the Internet to pull down the binaries and repo
2. The fly cli and credentials for your Concourse.
3. A token from your PivNet account
4. An instance of PKS 1.0.2 or 1.0.3 AND Harbor 1.4.x deployed on Ops Manager
5. Credentials for your Ops Manager
6. (optional) A token from your GitHub account

How to use the pipeline:

1. Download params.yml and pipeline.yml from here.
2. Edit the params.yml by replacing the values in double-parentheses with the actual value. Each line has a bit explaining what it’s expecting.  For example, ((ops_mgr_host)) becomes opsmgr.pcf1.domain.local
   • Remove the parens
   • If you have a GitHub Token, pop that value in, otherwise remove ((github_token))
   • The current pks_major_minor_version regex will get the latest 1.0.x.  If you want to pin it to a specific version, or when PKS 1.1.x is available, you can make those changes here.
   • The ops_mgr_usr and ops_mgr_pwd credentials are those you use to logon to Ops Manager itself.  Typically set when the Ops Manager OVA is deployed.
   • The schedule params should be adjusted to a convenient time to apply the upgrade.  Remember that in addition to the PKS Service being offline (it’s a singleton) during the upgrade, your Kubernetes clusters may be affected if you have the “Upgrade all Clusters” errand set to run in the PKS configuration, so schedule wisely!

   

3. Open your cli and login to concourse with fly
   

   fly -t concourse login -c http://concourse.domain.local:8080 -u username -p password

4. Set the new pipeline. Here, I’m naming the pipeline “PKS_Upgrade”. You’ll pass the pipeline.yml with the “-c” param and your edited params.yml with the “-l” param
   

   fly -t concourse sp -p PKS_Upgrade -c pipeline.yml -l params.yml

   Answer “y” to “Apply Configuration”…
   

5. Unpause the pipeline so it can run when in the scheduled window
   

   fly -t concourse up -p PKS_Upgrade

6. Login to the Concourse web to see our shiny new pipeline!
   
   If you don’t want to deal with the schedule and simply want it to upgrade on-demand, use the pipeline-nosched.yml instead of pipeline.yml, just be aware that when you unpause the pipeline, it’ll start doing its thing.  YMMV, but for me, it took about 8 minutes to complete the upgrade.

Behind the scenes
It’s not immediately obvious how the pipeline does what it does. When I first started out, I found it frustrating that there just isn’t much to the pipeline itself. To that end, I tried making pipelines that were entirely self-contained. This was good in that you can read the pipeline and see everything it’s doing; plus it can be made to run in an air-gapped environment. The downside is that there is no separation, one error in any task and you’ll have to edit the whole pipeline file.
As I learned a little more and poked around in what others were doing, it made sense to split the “tasks” out, keep them in a GitHub public repo and pull it down to run on-demand.

Pipelines generally have two main sections; resources and jobs.
Resources are objects that are used by jobs. In this case, the binary installation files, a zip of the GitHub repo and the schedule are resources.
Jobs are (essentially) made up of plans and plans have tasks.
Each task in most pipelines uses another source yml. This task.yml will indicate which image concourse should build a container from and what it should do on that container (typically, run a script). All of these task components are in the GitHub repo, so when the pipeline job runs, it clones the repo and runs the appropriate task script in a container built on an image pulled from dockerhub.

More info
I’ve got a several pipelines in the repo.   Some of them do what they’re supposed to. 🙂 Most of them are derived from others’ work, so many thanks to Pivotal Services and Sabha Parameswaran

PKS and NSX-T: I did everything wrong

I’ve fought with PKS and NSX-T for a month or so now. I’ll admit it: I did everything wrong, several times. One thing for certain, I know how NOT to configure it. So, now that I’ve finally gotten past my configuration issues, it makes sense to share the pain lessons learned.

1. Set your expectations correctly. PKS is literally a 1.0 product right now. It’s getting a lot of attention and will make fantastic strides very quickly, but for now, it can be cumbersome and confusing. The documentation is still pretty raw. Similarly, NSX-T is very young. The docs are constantly referring you to the REST API instead of the GUI – this is fine of course, but is a turn-off for many. The GUI has many weird quirks. (when entering a tag, you’ll have to tab off of the value field after entering a value, since it is only checked onBlur)
2. Use Chrome Incognito  NSX-T does not work in Firefox on Windows. It works in Chrome, but I had issues where the cache would problems (the web GUI would indicate that backup is not configured until I closed Chrome, cleared cache and logged in again)
3. Do not use exclamation point in the NSX-T admin password Yep, learned that the hard way. Supposedly, this is resolved in PKS 1.0.3, but I’m not convinced as my environment did not wholly cooperate until I reset the admin password to something without an exclamation point in it
4. Tag only one IP Pool with ncp/external I needed to build out several foundations on this environment and wanted to keep them in discrete IP space by created multiple “external IP Pools” and assigning each to its own foundation. Currently the nsx-cli.sh script that accompanies PKS with NSX-T only looks for the “ncp/external” tag on IP Pools, if more than one is found, it quits. I suppose you could work around this by forking the script and passing an additional “cluster” param, but I’m certain that the NSBU is working on something similar
5. Do not take a snapshot of the NSX Manager This applies to NSX for vSphere and NSX-T, but I have made this mistake and it was costly. If your backup solution relies on snapshots (pretty much all of them do), be sure to exclude the NSX Manager and…
6. Configure scheduled backups of NSX Manager I found the docs for this to be rather obtuse. Spent a while trying to configure a FileZilla SFTP or even IIS-FTP server until it finally dawned on me that it really is just FTP over SSH. So, the missing detail for me was that you’ll just need a linux machine with plenty of space that the NSX Manager can connect to – over SSH – and dump files to. I started with this procedure, but found that the permissions were too restrictive.
7. Use concourse pipelines This was an opportunity for me to really dig into concourse pipelines and embrace what can be done. One moment of frustration came when PKS 1.0.3 was released and I discovered that the parameters for vSphere authentication had changed. In PKS 1.0 through 1.0.2, there was a single set of credentials to be used by PKS to communicate with vCenter Server. As of 1.0.3, this was split into credentials for master and credentials for workers. So, the pipeline needed a tweak in order to complete the install. I ended up putting in a conditional to check the release version, so the right params are populated. If interested, my pipelines can be found at https://github.com/BrianRagazzi/concourse-pipelines
8. Count your Load-Balancers In NSX-T, the load-balancers can be considered a sort of empty appliance that Virtual Servers are attached to and can itself attach to a Logical Router. The load-balancers in-effect require pre-allocated resources that must come from an Edge Cluster. The “small” load-balancer consumes 2 CPU and 4GB RAM and the “Large” edge VM provides 8 CPU and 16GB RAM. So, a 2-node Edge Cluster can support up to FOUR active/standby Load-Balancers. This quickly becomes relevant when you realize that PKS creates a new load-balancer when a new K8s cluster is created. If you get errors in the diego databse with the ncp job when creating your fifth k8s cluster, you might need to add a few more edge nodes to the edge cluster.
9. Configure your NAT rules as narrow as you can. I wasted a lot of time due to mis-configured NAT rules. The log data from provisioning failures did not point to NAT mis-configuration, so wild geese were chased.  Here’s what finally worked for me:
   

   Router	Priority	Action	Source	Destination	Translated	Description
   Tier1 PKS Management	512	No NAT	[PKS Management CIDR]	[PKS Service CIDR]	Any	No NAT between management and services
   			[PKS Service CIDR]	[PKS Management CIDR]
   	1024	DNAT	Any	[External IP for Ops Manager]	[Internal IP for Ops Manager]	So Ops Manager is reachable
   				[External IP for PKS Service]	[Internal IP for PKS Service] (obtain from Status tab of PKS in Ops Manager)	So PKS Service (and UAA) is reachable
   		SNAT	[Internal IP for PKS Service]	Any	[External IP for PKS Service]	Return Traffic for PKS Service
   	2048		[PKS Management CIDR]	[Infrastructure CIDR] (vCenter Server, NSX Manager, DNS Servers)	[External IP for Ops Manager]	So PKS Management can reach infrastructure
   			[PKS Management CIDR]	[Additional Infrastructure] (NTP in this case)	[External IP for Ops Manager]
   Tier1 PKS Services	512	No NAT	[PKS Service CIDR]	[PKS Management CIDR]	Any	No NAT between management and services
   			[PKS Management CIDR]	[PKS Service CIDR]
   	1024	SNAT	[PKS Service CIDR]	[Infrastructure CIDR] (vCenter Server, NSX Manager, DNS Servers)	[External IP] (not the same as Ops Manager and PKS Service, but in the same L3 network)	So PKS Services can reach infrastructure
   			[PKS Service CIDR]	[Additional Infrastructure] (NTP in this case)	[External IP]

Resolutions for 2018

If I put it here, I’m much more likely to follow-through.  Like many, I work best under some pressure.  Here is a list of what I want to do differently (with regard to technology) next year.

1. Do more blogging.  I can make a ton of excuses for not blogging as much this year.  I love sharing what I’ve learned; the more new stuff I learn, the more I share.  So….
2. Do more for NSX for vSphere and NSX-T.  I feel strongly that SDN is critical to the future of how datacenters operate.  NSX is the logical leader in this space and will only grow in interest.  There is still a tendency to replicate what was done with pre-SDN technology and I’d like to see modern ways to solve problems while finding and pushing the limits of what can be done in SDN.
3. 
   Do more with containers and PKS.  The technologies that Pivotal provides are cutting edge.  Already and continuing, containers and applications-as-code methods are growing and will define the datacenter of the future.  Just as a few years ago, we stopped thinking of hardware servers as single-purpose, we’ll embrace multiple workloads within a VM.
4. Do more coding.  I love concourse and pipelines, but have a lot to learn.  Let’s find the limits of BOSH and pipelines.  Can we not only deploy, but automate the operation and maintenance of a PaaS solution?
5. Do more coding.  I feel that as we move to “applications-as-code”, it’s important to understand what that means to developers and operators.  What sort of problems become irrelevant in this approach?  What molehills become mountains?

Hope to see you next year!