Everpure Flash Array NFS: Making a read/writeable snapshot clone using a Python script

In this blog post I am going to build upon the example shown in my blog post Everpure Flash Array NFS: Making a read/writeable snapshot clone using the Purity GUI and show how to automate the process by leveraging the Purity REST API, and the pypureclient Python package.

The referenced post showed how to use the Purity GUI to clone one or more file systems that were part of a Pod in Purity. The cloned file systems could then be exported with new export names, and revised policies and rules. The approach allowed for the rapid cloning of the entire file system, which can be very useful for database administrators wishing to rapidly clone an NFS based database.

Furthermore, the cloned file systems consume very little capaciy. Since they are exact copies of the Pod that was cloned, the newly created file systems require only the delta that between the source and target. This can be very helpful when cloning larger databases when storage capacities are limited.

Whereas the GUI approach is simple enough that everyone should feel comfortable doing it, users may also require a scripted version that allows for execution under a job schedule, or if the DBA team does not have credentials to log into Purity.

Continue reading →

Everpure Flash Array NFS: Making a read/writeable snapshot clone using the Purity GUI

In this blog post I am going to show you how to make a read-writeable snapshot-clone of an NFS export on an Everpure Flash Array. This approach would allow you to make an almost instant “snapshot” clone of, for example, a large Oracle database that uses NFS on an Everpure Flash Array.

In my previous blog post Moving a Purity File System into a Pod, I observed that:

However, unlike block volume snapshots which may be instantly copied to new volumes providing for a nearly instant method to clone large databases, NFS snapshots work somewhat differently.

I then showed how you can move NFS exported file systems into a Pod. In this blog post we will clone that pod and all of the NFS exported file systems contained therein. Note that this process and these screen shots were taken on Purity 6.10.6. Releases of Purity that are older or newer may exhibit different behaviour.

Continue reading →

Moving a Purity File System into a Pod

The Everpure Flash Array provides native support for NFS and SMB, with Everpure stating that both block and file are “co-equal” first-class citizens, meaning that NFS and SMB are baked into Purity//FA and not an add-on. An NFS exported file system on Flash Array benefits from all the features and functionality of the platform, including the ability to make instance and very space efficient snapshots.

However, unlike block volume snapshots which may be instantly copied to new volumes providing for a nearly instant method to clone large databases, NFS snapshots work somewhat differently.

In this blog post I am going to show you to move an Everpure NFS exported file system into a Pod, so that it can be quickly cloned into a read/writeable state.

Continue reading →

Creating an NFS export on an Everpure Flash Array

NFS has long been a popular choice for storage for an Oracle database. The protocol is mature, robust and usually simple to consume. Oracle has embraced the standard with the dNFS extensions and support for RAC clustering. Furthermore, with the changes occuring in the Hypervisor market and the withdrawl of support for solutions like VVOLs, NFS provides a consistent vendor-neutral solution that spans hypervisors and bare metal systems.

The Everpure Flash Array has native support for NFS, along with SMB. Everpure states that Flash Array File is a “co-equal” first-class citizen with block on the Flash Array, meaning that NFS and SMB are baked into Purity//FA and not an add-on.

Like block, NFS and SMB file systems benefit from array-wide compression and deduplication, as well as Safe Mode ransomware protection. File systems can be also be replicated from one Flash Array to another, and there is now Active Cluster for File meaning that a file system can be made highly available even if a Flash Array fails, by providing access to the file system from more than one Flash Array.

In this blog post I am going to walk through creating an NFS file system on a Flash Array. These are mostly my lab notes to myself, but will also provide the foundation for a few future posts where I delve deeper into Oracle on NFS. Note that this process and these screen shots were taken on Purity 6.10.6. Releases of Purity that are older or newer may exhibit different functionality.

Continue reading →

A Long Overdue Blog Update

It’s been almost three years since I wrote any blog entries, but now I am back, and I plan to be adding some new content over the coming months. Hopefully, 2027 will be a productive year!

So where have I been? I am happy to share that in October 2024, I joined the then-named Pure Storage as a Field Solution Architect, focusing on structured data, databases, Oracle and Open Source. Since then, the company has grown larger and stronger, and was renamed Everpure this year. Everpure is a dynamic and innovative company, and one of the many great things about working at Everpure is that I once again have access to real hardware in an amazing lab!

Prior to Everpure, I had worked at EMC since 2012, and I have fond memories of my time at EMC and then Dell Technologies, which acquired EMC in 2016. I still have many friends there and I wish them well.

Like everyone else in technology, I have watched over the last three years as AI has exploded from a remarkable niche into a technology that touches everything we do.

And I suppose one of the reasons I have been less motivated to blog over the last 24 months has been the growth of AI, which continues to revolutionize our work and our lives. I found myself asking, “Why bother blogging in the age of AI?”

Continue reading →

Monitoring Oracle Database Performance with Grafana – Part II

This the second part of a blog post on using the Grafana graphing tool to create an Oracle database performance dashboard for monitoring host and database performance in real time.

In the previous blog post I created a process to read key metrics from Oracle and insert them into a PostgreSQL database. This intermediate step was necessary as the free edition of Grafana does not include the connector to read directly from Oracle.

Once the metrics were loaded into a PostgreSQL table, a second process calculated deltas for those Oracle metrics that are cumulative. The results were then read by Grafana to show host performance and also report on the number of connected Swingbench users.

In this blog post I am going to expand on that and add IO metrics to track read and write IOPs and also throughput.

There is a video for this blog

As before, all code is available from my GitHub repository.

If you have not read Part I, you can find it here

Continue reading →

Monitoring Oracle Database Performance with Grafana – Part I

In a previous blog post I explored how we can use Oracle’s rich V$ views to monitor CPU utilization on the host on which our database is running, as well as the IO generated by all nodes of the database.

Numbers are great, but it would be even better to see the loads represented graphically on a dashboard for an immediate read on how the database and the underlying infrastructure is handling the workload.

In this blog post I will use the Grafana visualization package to create a simple performance dashboard for our Oracle database.

There is a video for this blog

All code is available on GitHub

If you are looking for Part II, you can find it here
Continue reading →

Calculating IOPS and Throughput from GV$FILESTAT and GV$IOSTAT_FILE

In a recent blog post I explored how to monitor the database hosts’ CPU utilization from inside of the Oracle database using the V$OSSTAT view. Although not as comprehensive as native OS tools, the approach offered a quick and simple method for Oracle DBAs to leverage the existing software installed and established network connectivity to overlay a simple host monitoring layer that could track CPU utilization rates, and possibly identify CPU starvation risk, or over-provisioned database hosts in a manner that is largely platform neutral and works regardless of any hypervisor.

In this post I am going to explore how to use how to monitor database IOPS and storage throughput in close-to-real-time, again using the databases’ interval views. Once again our approach will likely not be as comprehensive as native OS tools, but will offer Oracle DBAs a quick and simple additional method to track the storage performance of their databases. In addition, since the Oracle internal views track only the database IO, and not IO generated from other applications, our DBAs can be confident that the numbers represent what the database has generated and is experiencing, undiluted by peripheral activities.

Continue reading →

Calculating Host Utilization using V$OSSTAT

Since the move to all flash storage solutions, about ten years ago, CPU utilization and bottlenecks have frequently become the primary cause of performance concerns for Oracle DBAs. Whereas in the past the top wait events seen in a Statspack or AWR report might be “db file scattered read” or “db file sequential read”, our contemporary DBA is far more likely to see “CPU” atop the list.

It is important to remember that seeing “CPU” atop the wait events in an AWR report might indicate that the host CPUs are saturated, or it might indicate that there are single threaded processes within the database that are waiting on a single core to complete a compute operation.

And there is a trade off between more cores and clock speed. Generally speaking, within each generation of CPU, more cores means a slower clock. A denser processor with more cores will be able to handle a larger number of simultaneous compute operations – ideal of parallel query processing, analytics, AI and consolidation, whereas a lower core count with a higher clock speed is generally better suited for transaction processing applications, as well as being dramatically less expensive to license for the Oracle software.

Keeping an eye on host utilization then is an important part of an operational DBAs task list, and there are many excellent tools to do this across a large enterprise. In this post we explore a simple method to monitor host utilization from within the database, meaning that our DBA can use SQL*Plus access via TNS to databases to keep track of the underlying hosts.

Continue reading →

Delete a storage snapshot of an Oracle 19c RAC database using ASM diskgroups with Dell PowerMax.

In this post I am going to explore deleting a storage snapshot of an Oracle 19c RAC database created on a Dell PowerMax storage array.

This post is a companion to the video Dell PowerMax – Refresh a storage snapshot of Oracle RAC database. and a follow on from the blog post Create a storage snapshot of an Oracle 19c RAC database using ASM diskgroups with Dell PowerMax.

This blog post assumes some basic knowledge of PowerMax storage concepts. If you need a basic introduction please check out my PowerMax basics video.

These examples will use the Solutions Enabler command line method of managing the PowerMax, unlike the video which uses the Unisphere graphical interface.

Continue reading →