February 12, 2024 — River Point Technology (RPT), announced today that CRN®, a brand of The Channel Company, has named RPT to its Managed Service Provider (MSP) 500 list in the Elite 150 category for 2024.

The MSP 500 list compiled by CRN serves as a comprehensive guide to identifying and recognizing the top Managed Service Providers (MSPs) in North America. MSPs play a crucial role in supporting businesses by offering managed services that enhance efficiency, simplify IT solutions, and optimize return on investment.

The annual MSP 500 list is divided into three sections: the MSP Pioneer 250, recognizing companies with business models weighted toward managed services and largely focused on the SMB market; the MSP Elite 150, recognizing large, data center-focused MSPs with a strong mix of on- and off-premises services; and the Managed Security 100, recognizing MSPs focused primarily on off-premises and cloud-based security services.

The MSP 500 list aims to showcase and celebrate MSPs that are driving growth and innovation in the industry. These service providers not only enable businesses to harness complex technologies but also contribute to maintaining a strong focus on core business goals without stretching financial resources. By categorizing MSPs based on their business models and areas of expertise, the list helps end-users find the right partners to meet their specific needs and challenges in the rapidly evolving technology landscape.

River Point Technology is a recognized leader in cloud and DevOps services, supporting Fortune 500 companies in accelerating digital transformation and pushing boundaries. Our dedicated team of engineers and architects makes deploying, integrating, and managing new technology easier by providing cutting-edge custom solutions. We also help organizations achieve ongoing success and maximize the value of their technology investments through top-notch enablement programs.

Jennifer Follett, VP of US Content and executive Editor CRN, T he Channel Company, emphasized the significance of managed services for businesses at various scales, stating, “Managed services provide a route for businesses of all sizes to maintain efficiency and adaptability throughout their growth journey. The solution providers featured in our 2024 MSP 500 list are introducing cutting-edge managed services portfolios to the market, enabling their clients to achieve success by optimizing their IT budgets. This allows businesses to allocate resources strategically, concentrating on mission-critical tasks that drive future success.”

“Our core value is driving successful outcomes for our customers, so it is satisfying to see this being acknowledged by our inclusion on the CRN MSP500 list as an Elite 150 partner. I am incredibly proud of our team for their dedication and commitment to being the best in their craft which allows us to bring this value to our customers. We will continue to innovate and humanize technology by leveraging our Value Creation Technology process.” said RPT’s owner and CEO Jeff Eiben.

The MSP 500 list will be featured in the February 2024 issue of CRN and online at www.crn.com/msp500.

About River Point Technology

River Point Technology (RPT) is an award-winning cloud and DevOps service provider that helps Fortune 500 companies accelerate digital transformation and redefine what is possible. Our passionate team of engineers and architects simplify the deployment, integration, and management of emerging technology by delivering state-of-the-art custom solutions. We further position organizations to experience Day 2 success at scale and realize the value of their technology investments by offering best-in-class enablement opportunities. These include the subscription-based RPT Resident Accelerator program that’s designed to help enterprises manage the day-to-day operations of an advanced tech stack, the just-launched RPT Connect App, and our expert-led training classes. Founded in 2011, our unique approach to evaluating and adopting emerging technology is based on our proprietary and proven Value Creation Technology process that empowers IT teams to boldly take strategic risks that result in measurable business impact. What’s your vision? Contact River Point Technology today and see what’s possible.

About The Channel Company

The Channel Company enables breakthrough IT channel performance with our dominant media, engaging events, expert consulting and education, and innovative marketing services and platforms. As the channel catalyst, we connect and empower technology suppliers, solution providers and end users. Backed by more than 40 years of unequalled channel experience, we draw from our deep knowledge to envision innovative new solutions for ever-evolving challenges in the technology marketplace. www.thechannelco.com

Follow The Channel Company: Twitter, LinkedIn, and Facebook.

© 2024 The Channel Company LLC. CRN is a registered trademark of The Channel Company, LLC. All rights reserved.

The Channel Company Contact:

Kristin DaSilva

The Channel Company


In the dynamic realm of container orchestration and secrets management, the integration of Kubernetes with HashiCorp Vault stands as a pivotal undertaking, offering enhanced security and streamlined operational workflows. However, this collaboration is not without its complexities, presenting a set of formidable challenges that organizations must navigate. From intricacies in configuration to ensuring seamless communication between these powerful tools, the journey to successfully integrate Kubernetes with HashiCorp Vault demands a strategic approach.

In this exploration, we delve into the top 10 challenges faced in this integration process, shedding light on the key hurdles that organizations encounter and providing insights into overcoming these obstacles for a robust and secure deployment. Here are the top 10 challenges you might face:

Authentication and Authorization: Configuring proper authentication and authorization mechanisms to control access to Vault secrets for both Kubernetes and traditional applications can be challenging.

Secrets Management: Managing secrets across different platforms, ensuring their security, and automating their lifecycle is a fundamental challenge.

Secret Rotation: Implementing automated secret rotation policies and procedures for secrets stored in Vault can be complex, especially for legacy applications that may not support dynamic secret retrieval.

Networking and Security: Establishing secure communication between Kubernetes pods, traditional applications, and Vault while maintaining network segmentation and firewall rules can be tricky.

Integration Complexity: Integrating Vault with a variety of application types, databases, and cloud services, especially when dealing with legacy systems, can lead to integration complexities.

Compliance and Auditing: Meeting compliance requirements and tracking access and usage of secrets for auditing purposes can be challenging, especially in regulated industries.

Secrets Versioning: Managing different versions of secrets, ensuring backward compatibility, and handling secrets rotation gracefully can be complex.

Backup and Disaster Recovery: Developing and testing robust backup and disaster recovery plans for Vault’s data and configurations is crucial to ensure business continuity.

Monitoring and Alerting: Setting up monitoring and alerting solutions to detect and respond to any issues or breaches in real-time is a significant challenge.

Documentation and Training: Ensuring that your team has the necessary skills and knowledge to manage and troubleshoot the integrated environment is an ongoing challenge, as technologies evolve.

Certainly, the real challenges linked to the widespread use of DevOps tools are undeniable. This is why numerous organizations caught in the predicament of managing multiple DevOps platforms are choosing to streamline by consolidating into a central platform. Yet, what does this consolidation involve, and how do you determine the optimal single DevOps platform for migration?  Read this Case Study for more answers.

HashiCorp’s Terraform Cloud provides a centralized platform for managing infrastructure as code. It’s a leading provider in remote Terraform management with remote state management, automated VCS integrations, and cost visibility. One of its features, a private registry, can be used to develop internal Terraform providers where control, security, and customizations are paramount.

Let’s explore an example using the Terraform Provider Scaffolding Framework to build a custom Terraform provider and publish it to a private registry. Scaffold provides a framework starter kit that you can use out of the box to replace your APIs.

Signing Your Provider

Code signing guarantees that the generated artifacts originate from your source, allowing users to verify this authenticity by comparing the produced signature with your publicly available signing key. It will require you to generate a key pair through the GNU PGP utility. You can develop this by using the command below, be sure to replace GPG_PASSWORD and your name with values that make sense.

gpg --default-new-key-algo rsa4096 --batch --passphrase "${GPG_PASSWORD}" --quick-gen-key 'Your Name <name@example.com>' default default

Export Public Key

With your newly generated key securely stored, the next step involves exporting and uploading it to Terraform Cloud. This action facilitates verification while deploying your signed artifacts, and ensuring their authenticity within the platform’s environment. The GPG Key API requires the public key to validate the signature. To access the list of key IDs, you can execute: gpg --list-secret-keys --keyid-format LONG. The key is denoted in the output.

sec   rsa4096/<KEY ID> 2023-11-22 [SC] [expires: 2026-11-21]

You can then get your public key as a single string. KEY=$(gpg --armor --export ${KEY_ID} | awk '{printf "%sn", $0}'). You’ll then need to build a payload with the output of that file and POST that to https://app.terraform.io/api/registry/private/v2/gpg-keys. The ORG_NAME is your Terraform cloud organization.

  "data": {
        "type": "gpg-keys",
        "attributes": {
            "namespace": "${ORG_NAME}",
            "ascii-armor": "${KEY}"

Export Private Key for CI/CD (Optional)

If you plan to use this key in a CI Platform, you can also export the key and upload it gpg --export-secret-keys --armor ${KEY_ID} > /tmp/gpg.pgp to a secure Vault.

Packaging Terraform Providers with GoReleaser

GoReleaser simplifies the process of building and releasing Go binaries. Using GoReleaser, we can bundle different architectures, operating systems, etc.

You will need to create a terraform registry manifest, the protocol version is essential.  If you are using Plugin Framework, you will want version 6.0. If you are using Plugin SDKv2, you will want version 5.0.

    "version": 1,
    "metadata": {
      "protocol_versions": ["6.0"]

Configuring GoReleaser

Ensure your goreleaser.yml configuration includes settings for multi-architecture support and signing. This file should live at the provider’s root, next to your main codebase.

    - go mod tidy
- env:
  mod_timestamp: '{{ .CommitTimestamp }}'
    - -trimpath
    - '-s -w -X main.version={{ .Version }} -X main.commit={{ .Commit }}'
    - freebsd
    - windows
    - linux
    - darwin
    - amd64
    - '386'
    - arm
    - arm64
    - goos: darwin
      goarch: '386'
  binary: '{{ .ProjectName }}_v{{ .Version }}'
- format: zip
  name_template: '{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}'
    - glob: 'terraform-registry-manifest.json'
      name_template: '{{ .ProjectName }}_{{ .Version }}_manifest.json'
  name_template: '{{ .ProjectName }}_{{ .Version }}_SHA256SUMS'
  algorithm: sha256
  - artifacts: checksum
      - "--batch"
      - "--local-user"
      - "{{ .Env.GPG_FINGERPRINT }}"
      - "--output"
      - "${signature}"
      - "--detach-sign"
      - "${artifact}"
    stdin: '{{ .Env.GPG_PASSWORD }}'
    - glob: 'terraform-registry-manifest.json'
      name_template: '{{ .ProjectName }}_{{ .Version }}_manifest.json'
  skip: true

Tag your Branch

git tag 0.0.1
git checkout 0.0.1

Your git strategy may differ, but GoReleaser uses branch tags to determine versions.

Bundle and Sign Binaries

Execute GoReleaser to bundle the binaries locally without publishing. We skipped publishing as we will manually upload them to Terraform Cloud.

export GPG_TTY=$(tty)
goreleaser release --skip=publish

Now we have our artifacts.

Publishing to Terraform Cloud Private Registry

Once you have the signed binaries, you can publish them to the Terraform Cloud private registry. HashiCorp provides a guide, which we will follow.

Workflow for releasing a signed provider, including development, signing, tagging, and user deployment of resource.

Register the provider (first time only)

Create a provider config file and POST that body utilizing your Terraform Cloud API token. A provider name is usually a singular descriptor representing a business unit, such as Google or AWS.

curl --header "Authorization: Bearer ${TERRAFORM_CLOUD_API_TOKEN}" 
--header "Content-Type: application/vnd.api+json" 
--request POST 
-d @- 
"https://app.terraform.io/api/v2/organizations/${ORG_NAME}/registry-providers" <<EOT

  "data": {
    "type": "registry-providers",
    "attributes": {
      "name": "${PROVIDER_NAME}",
      "namespace": "${ORG_NAME}",
      "registry-name": "private"

Uploading your Versions

Create Version Shell within Private Registry Providers

curl -H "Authorization: Bearer ${TOKEN}" 
  -H "Content-Type: application/vnd.api+json" 
 --request POST 
  -d @- 
"https://app.terraform.io/api/v2/organizations/${ORG_NAME}/registry-providers/private/${ORG_NAME}/${PROVIDER_NAME}/versions" <<EOT

  "data": {
    "type": "registry-provider-versions",
    "attributes": {
      "version": "${VERSION}",
      "key-id": "${KEY_ID}",
      "protocols": ["6.0"]

The response will contain upload links that you will use to upload the SHA256SUMS and SHA256.sig files.

"links": {
    "shasums-upload": "https://archivist.terraform.io/v1/object/dmF1b64hd73ghd63",
    "shasums-sig-upload": "https://archivist.terraform.io/v1/object/dmF1b37dj37dh33d"

Upload Signatures.

# Replace ${VERSION} and ${PROVIDER_NAME} with actual values
curl -sS -T "dist/terraform-provider-${PROVIDER_NAME}_${VERSION}_SHA256SUMS" "${SHASUM_UPLOAD}"
curl -sS -T "dist/terraform-provider-${PROVIDER_NAME}_${VERSION}_SHA256SUMS.sig" "${SHASUM_SIG_UPLOAD}"

Register Platform for every Architecture and Operating System.

SHA=$(shasum -a 256 "dist/${FILENAME}" | awk '{print $1}' )
# OS ex. darwin/linux/windows# ARCH ex. arm/amd64# FILENAME. terraform-provider-<PROVIDER_NAME>_<VERSION>_<OS>_<ARCH>.zip. Define through name_template

curl -H "Authorization: Bearer ${TOKEN}" 
 -H "Content-Type: application/vnd.api+json" 
 --request POST 
 -d @- 
  "https://app.terraform.io/api/v2/organizations/${ORG_NAME}/registry-providers/private/${ORG_NAME}/${PROVIDER_NAME}/versions/${VERSION}/platforms" << EOT
    "data": {
        "type": "registry-provider-version-platforms",
        "attributes": {
            "shasum": "${SHA}",
            "os": "${OS}",
            "arch": "${ARCH}",
            "filename": "${FILENAME}"

The response will contain upload the provider binary to:

"links": {
  "provider-binary-upload": "https://archivist.terraform.io/v1/object/dmF1b45c367djh45nj78"

Upload archived binaries

curl -sS -T "dist/${FILENAME}" "${PROVIDER_BINARY_URL}"

Repeat step: Register Platform for every Architecture and Operating System and step: Upload Archived Binaries for every architecture and operating system.

Using the provider

Private providers hosted within Terraform Cloud are only available to users within the organization.

When developing locally, ensure you set up credentials through the terraform login, creating a credentials.tfrc.json file.

With the authentication bits setup, you can utilize the new provider by defining the provider block substituting in those existing variables.

terraform {
  required_providers {
    ${PROVIDER_NAME} = {
      source = "app.terraform.io/${ORG_NAME}/${PROVIDER_NAME}"
      version = "${VERSION}"

provider "${PROVIDER_NAME}" {
  # Configuration options

Document Provider

For user consumption, a common practice is to provide provider documentation for your resources utilizing Terraform plugin docs. This plugin generator allows you to generate markdowns from examples and schema definitions, which users can then consume. At the time of publication, this feature is currently not supported within the Terraform Cloud. Please talk to your River Point Technology representative for alternative solutions.


To remove the provider from the registry:

Delete version

curl -H "Authorization: Bearer ${TOKEN}" 
 --request DELETE 

Delete provider

curl -H "Authorization: Bearer ${TOKEN}" 
 --request DELETE 

Deregister GPG Key

curl -H "Authorization: Bearer ${TOKEN}" 
 --request DELETE 


With a private registry, you get all the benefits of Terraform while still allowing internal consumption. This may be desirable when public providers don’t meet your use case and it comes with a host of benefits:

  1. More Customization and Control: A private registry allows organizations to maintain control over their proprietary or custom-built Terraform providers. It enables them to manage, version, and distribute these providers securely within the organization.
  2. Better Security and Compliance: A private registry ensures that only authorized users within the organization can access and utilize specific Terraform providers for sensitive or proprietary infrastructure configurations. This control aids in compliance with internal policies and regulatory requirements.
  3. Improved Versioning and Stability: With a private registry, teams can maintain a stable versioning system for their Terraform providers. This helps ensure project infrastructure configurations remain consistent and compatible with the specified provider versions.

Publishing custom Terraform providers to the Terraform Cloud private registry involves bundling, signing, and uploading binaries and metadata through the API. Following these steps, you can effectively manage and distribute your Terraform provider to support various architectures and operating systems.

River Point Technology (RPT) is here to guide you through the intricacies of exploring the dynamic cloud landscape. If you’re facing challenges and need assistance in achieving increased customization and oversight, enhanced security and compliance, along with improved versioning and stability, feel free to leave a comment or reach out to us directly.

As the HashiCorp Global Competency Partner of the Year and the only company certified in all three competencies—Security, Networking, and Infrastructure—we stand out as a market leader. Trusted by Fortune 500 companies, we serve as their guide in effectively navigating the dynamic cloud terrain. Contact RPT for guidance in optimizing the journey through the cloud landscape.