Language Selection

English French German Italian Portuguese Spanish

Preparing for Y2038 (Already?!)

Filed under
Linux

It somehow doesn't seem that long ago, but nineteen years ago during Y2K I spent my New Year's Eve in the Akamai Network Operations center, waiting to respond to anything that might go awry as the clock struck midnight in key time zones such as Greenwich and Boston. As of January 9, 2019, we are roughly half-way from Y2K to "Y2038", the next large time epoch roll-over event. In 2038 on January 19th the "Unix Epoch Time" will exceed the size of a signed 32-bit integer "time_t" value (231-1), or roughly 2.1 billion seconds since the epoch of 00:00:00 on January 1, 1970. We have somewhat more time to deal with the systems that will break nineteen years from now. However, as we get closer there will be increasing impacts on software working with future dates.

Shortly after Y2K we made jokes about "next up, Y2038!" but back then it felt an eternity in the future and likely to be someone else's problem. Now that we're halfway there, and we have already reached the point where Y2038 issues can cause software failures, it is a good opportunity to start planning for Y2038. For example, software may already be having issues working with 20-year certificate lifetimes or 20-year mortgages, and the frequency of these issues will only increase as we get closer to Y2038. At Akamai we are already running strategically-targeted internal planning and testing for Y2038, and it seems likely that the scope of this work will continue to grow over the next 19 years as this important effort increases in urgency.

Very little went wrong on January 1, 2000 for us (short of some Javascript on an Akamai marketing site displaying "1900" as the current date!), but one thing that gets missed is that the limited global impact that evening was due to two factors: 1) the amount of advanced preparation that was done; 2) many "Y2K problems" actually occurred years in advance rather than during the roll-over itself. Leap seconds are in some ways scarier than date-format issues in that they are harder to test for and much less of the impact happens in advance. There is a risk that the lack of impacts of Y2K may cause organizations and technologists to under-prepare for Y2038. It is also harder to explain "Y2038" to lay people than Y2K, potentially making it harder to prioritize and focus advanced work. The large number of embedded Internet of Things (IoT) devices becoming ubiquitous in our environment also makes the likely risk and potential impact considerably higher for Y2038 than it was for Y2K.

Read more

More in Tux Machines

Reducing sysadmin toil with Kubernetes controllers

Kubernetes is a platform for reducing toil cunningly disguised as a platform for running containers. The element that allows for both running containers and reducing toil is the Kubernetes concept of a Controller. [...] The canonical example of this in action is in how we manage Pods in Kubernetes. A Pod is effectively a running copy of an application that a specific worker node is asked to run. If that application crashes, the kubelet running on that node will start it again. However, if that node crashes, the Pod is not recovered, as the control loop (via the kubelet process) responsible for the resource no longer exists. To make applications more resilient, Kubernetes has the ReplicaSet controller. The ReplicaSet controller is bundled inside the Kubernetes controller-manager, which runs on the Kubernetes master node and contains the controllers for these more advanced resources. The ReplicaSet controller is responsible for ensuring that a set number of copies of your application is always running. To do this, the ReplicaSet controller requests that a given number of Pods is created. It then routinely checks that the correct number of Pods is still running and will request more Pods or destroy existing Pods to do so. By requesting a ReplicaSet from Kubernetes, you get a self-healing deployment of your application. You can further add lifecycle management to your workload by requesting a Deployment, which is a controller that manages ReplicaSets and provides rolling upgrades by managing multiple versions of your application's ReplicaSets. Read more

Android Leftovers

Server: IBM, LAMP and Kubernetes

  • A HATS For Many Occasions
    IBM gives customers plenty of options when it comes to its Rational Host Access Transformation software, including several modes of operation, different runtime options, and support for different operating systems in screen modernization engagements. With last week’s launch of HATS version 9.7, the development and deployment options got even wider. Regardless of which downstream options a HATS customer ultimately chooses, it all starts out basically the same on the front side of the sausage machine: Customers come to HATS because they have a 5250 (or 3270 or VT100) application that they want to transform, but they don’t want to go through the hassle, expense, and risk of modifying the IBM i, z/OS, or Unix application’s source code.
  • Six top skills that you should acquire in 2019
    There is a growing demand for the fullstack development skill set, which is the ability to develop tech both on the front-end/client side and back-end/server side. As you can’t learn all, select combinations like MEAN or LAMP stack.
  • Kubernetes and the Enterprise
    The reason we were having this conversation was around SUSE’s Cloud Application Platform (CAP). This is our Kubernetes focused Cloud Foundry distribution. And as part of the Kubernetes focus, we have been supporting and running SUSE CAP on Azure’s AKS for the last year or so. The conversation continued with observations that Kubernetes was clearly the future across IT. Yet to date, Cloud Foundry still has a good following with the large enterprise. And the thinking was that the Cloud Foundry approach really helped the large enteprise work with their applications, even if the applications were purely ‘container’ applications. Cloud Foundry makes the container-side of managing your ‘container’ application transparent. This approach ultimately lowers the tasks, breadth of tooling, and knowledge you have to surround Kubernetes with. It was with this thought, that a light-bulb went on.

today's howtos