Skip to content

Latest commit

 

History

History
165 lines (129 loc) · 5.89 KB

README.md

File metadata and controls

165 lines (129 loc) · 5.89 KB
Raw

How to work with the library

The complete library is arranged around area specific Context objects, which bundle all the settings and supported extension points of the Open Component Model. Extension points are implemented by handlers that can be registered at dedicated context objects or at the default runtime environment. The context then provides all the methods required to access elements managed in the dedicated area.

The examples shown here provide an overview of the library. A more detailed annotated tour through various aspects of the library with ready-to work examples can be for here.

In the comparison scenario there is an example for an end-to-end scenario, from providing a component version by a software provider, over its publishing up to the consumption in an air-gapped environment, and the final deployment in this environment. Especially the deployment part just wants to illustrate the basic workflow using a Helm chart based example. It is not intended to be used as productive environment.

Working with OCM repositories

For working with OCM repositories an appropriate context, which can be used to retrieve OCM repositories, can be accessed with:

import "github.com/open-component-model/ocm/pkg/contexts/ocm"


func MyFirstOCMApplication() {
   octx := ocm.DefaultContext()
   
   ...
}

If a decoupled environment with dedicated special settings is required, the builder methods of the ocm package (With...) can be used to compose a context.

With ocm.New() a fresh ocm context is created using the default settings. It is possible to create any number of such contexts.

The context can then be used to gain access to (OCM) repositories, which provide access to hosted components and component versions.

To access a repository, a repository specification is required. Every repository type extension supported by this library uses its own package under github.com/open-component-model/ocm/pkg/contexts/ocm/repositories. To access an OCM repository based on an OCI registry the package github.com/open-component-model/ocm/pkg/contexts/ocm/repositories/ocireg contains the appropriate language binding for the OCI registry mappings.

Those packages typically have the method NewRepositorySpec to create an appropriate specification object for a concrete instance.

  repoSpec := ocireg.NewRepositorySpec("ghcr.io/mandelsoft/ocm", nil)

  repo, err := octx.RepositoryForSpec(repoSpec)
  if err != nil {
          return err
  }
  defer repo.Close()

Once a repository object is available it can be used to access component versions.

  compvers, err := repo.LookupComponentVersion(componentName, componentVersion)
  if err != nil {
          return err
  }
  defer compvers.Close()

The component version now provides access to the described content, the component descriptor, resources, sources, component references, and signatures.

The component descriptor is accessible by a standardized Go representation, which is independent of the actually used serialization format. If can be encoded again in the original or any other supported scheme versions.

  cd := compvers.GetDescriptor()
  data, err := compdesc.Encode(cd)
  if err != nil {
          return err
  }

Any resource (or source) can be accessed by getting the appropriate resource object by its resource identity in the context of the component version.

  res, err := compvers.GetResource(metav1.NewIdentity(resourceName))
  if err != nil {
          return err
  }

  fmt.Printf("resource %s:\n  type: %s\n", resourceName, res.Meta().Type)

The content of a described resource can be accessed using the appropriate access method described as part of the resource specification (another extension point of the model). It is described by an access specification. Supported methods can be directly be requested using the resource object.

  meth, err := res.AccessMethod()
  if err != nil {
          return err
  }
  defer meth.Close()

  fmt.Printf("  mime: %s\n", meth.MimeType())

The access method then provides access to the technical blob content. Here a stream access or a byte array access is possible.

  data, err = meth.Get()
  if err != nil {
          return err
  }

  fmt.Printf("  content:\n%s\n", utils.IndentLines(string(data), "    ",))

Besides this simple example, there are more usage scenarios, which typicaly require more configuration:

End-to-end Scenario.

In folder comparison-scenario there is an example for an end-to-end scenario, from building a component version to publishing, consuming and deploying it in a separate environment. It shows the usage of the OCM library to implement all the required process steps.

It builds a component version for the podinfo helm chart. There are two scenarios:

  • provisioning
    • building a component version with a helm based deployment description
    • signing it and
    • publishing it
  • consumption in a separate repository environment
    • tranferring the component version into a separate repository environment.
    • using the deployment description to localize the helm chart value - preparing values to refer to the podinfo OCI image available in the local environment.
    • finally deploying it with helm.