5 Provisionnement d'une instance

Cette section décrit comment provisionner votre instance Oracle Blockchain Platform à l'aide du gestionnaire de plate-forme Blockchain.

Avant de créer une instance Oracle Blockchain Platform

Avant de provisionner Oracle Blockchain Platform, déterminez si une instance de développeur ou d'entreprise répond à vos besoins.

Décider de la forme de provisionnement à utiliser

Lors du provisionnement d'une instance, vous choisissez entre deux configurations. La migration entre ces options n'est pas prise en charge actuellement.

Configuration Fonctions
Développeur

L'utilisation recommandée pour cette forme de départ est le développement et l'évaluation.
  • 1 noeud Fabric-CA
  • Réseau de service de commande de tissu à 3 noeuds
  • Référentiel à 1 noeud pour les métadonnées d'instance
  • conteneurs d'exécution de code de chaîne gérés dynamiquement
  • Service de console pour l'interface utilisateur Web des opérations
  • Service mandataire REST pour l'API RESTful
  • Intégration du serveur LDAP pour l'authentification et la gestion des rôles
Entreprise

Configuration d'instance hautement disponible, avec un nombre de répliques supérieur pour chaque service.

  • 3 noeuds Fabric-CA
  • Réseau de service de commande de tissu à 3 noeuds
  • Référentiel de grappes à 3 noeuds pour une haute disponibilité des métadonnées d'instance
  • conteneurs d'exécution de code de chaîne gérés dynamiquement
  • Service de console pour l'interface utilisateur Web des opérations
  • Répliques multiples pour le service mandataire REST pour l'API RESTful
  • Intégration du serveur LDAP pour l'authentification et la gestion des rôles

Provisionner une instance à l'aide du gestionnaire Blockchain Platform

Pour créer une instance du fondateur ou du participant de la chaîne de blocs dans le gestionnaire de plate-forme de chaîne de blocs, utilisez l'Assistant Créer une nouvelle instance.

Vous pouvez provisionner deux types d'instance Oracle Blockchain Platform :

  • Organisation fondatrice : Environnement complet de chaîne de blocs, notamment un nouveau réseau auquel les participants peuvent accéder plus tard.

  • Instance participante : S'il existe déjà une organisation fondatrice à laquelle vous souhaitez vous joindre, vous pouvez créer une instance participante si vos données d'identification vous permettent d'accéder au réseau. Notez qu'un participant ne peut pas fonctionner seul.

  1. Dans Gestionnaire de plate-forme de chaîne de blocs, ouvrez la page Instances.
  2. Sélectionnez Créer une instance.
  3. Remplissez les champs suivants :
    Champ Description
    Nom de l'instance

    Entrez un nom pour votre instance Oracle Blockchain Platform.

    Nom de l'instance de service :

    • Doit contenir un ou plusieurs caractères.
    • Ne doit pas dépasser 15 caractères.
    • Doit commencer par une lettre ASCII : a à z.
    • Ne doit contenir que des lettres ou des chiffres ASCII.
    • Ne doit pas contenir de tiret.
    • Ne doit pas contenir d'autres caractères spéciaux.
    • Doit être unique au sein du domaine d'identité.
    Description

    Facultatif.

    Entrez une brève description de l'instance Oracle Blockchain Platform.

    Nom du domaine

    Entrez le nom de domaine de la grappe.

    Les noms d'hôte générés pour les services d'instance de chaîne de blocs utilisent respectivement le nom de domaine et le nom d'instance comme domaine parent et sous-domaine.
    Rôle

    Sélectionnez Fondateur pour créer un environnement de chaîne de blocs complet. Cette instance devient l'organisation fondatrice et vous pourrez intégrer de nouveaux participants au réseau plus tard.

    Sélectionnez Participant pour créer une instance qui joindra un réseau de chaîne de blocs existant créé ailleurs avant que cette instance puisse être utilisée.

    Configuration
    Sélectionnez une forme de provisionnement qui répond aux besoins de votre déploiement :
    • Développeur
    • Entreprise
    Pairs

    Spécifiez le nombre de noeuds pairs à créer initialement dans cette instance de service. Vous pouvez créer des noeuds pairs supplémentaires dans la console Oracle Blockchain Platform ultérieurement.

  4. Cliquez sur Créer une instance.

Post-requis de provisionnement

Avant d'accéder à la console de service Oracle Blockchain Platform, configurez la résolution des noms d'hôte pour les services d'instance de chaîne de blocs, comme vous l'avez fait précédemment pour les noms d'hôte Blockchain Platform Manager. Utilisez la commande suivante pour obtenir la liste des noms d'hôte de l'instance de chaîne de blocs créée :
kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]
Avant d'accéder à la console de service Oracle Blockchain Platform, configurez la résolution du nom d'hôte pour les services d'instance de chaîne de blocs, comme vous l'avez fait précédemment pour les noms d'hôte Blockchain Platform Manager. Utilisez la commande suivante pour obtenir la liste des noms d'hôte de l'instance de chaîne de blocs créée :
kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]

Après avoir créé une instance Oracle Blockchain Platform Enterprise Edition, vous devez configurer un DNS afin que les noms d'hôte publics des composants puissent être résolus à partir du réseau local OpenShift.

Après avoir créé une instance, le nom de l'instance et le domaine parent sont utilisés en tant que sous-domaine pour les composants Oracle Blockchain Platform Enterprise Edition. Vous devez configurer le transfert DNS sur la configuration DNS par défaut pour OpenShift, de sorte que les demandes DNS soient transmises au module de réseautage DNS personnalisé où les services exposés sont résolus. Effectuez les étapes suivantes pour configurer le transfert DNS.
  1. Exécutez la commande suivante .
    oc new-project obp-coredns
  2. Déployez un serveur coredns personnalisé dans l'espace de noms obp-coredns en exécutant la commande suivante.
    kubectl apply -f <coredns-deployment-yaml-file>
    Utilisez le fichier manifeste suivant avec la commande.
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: obp-coredns
data:
  Corefile: |-
    .:1053 {
      errors
      health {
        lameduck 5s
      }
      ready
      kubernetes cluster.local in-addr.arpa ip6.arpa {
        pods insecure
        fallthrough in-addr.arpa ip6.arpa
      }
      prometheus :9153
      forward . /etc/resolv.conf
      cache 30
      loop
      reload
      loadbalance
    }
    import custom/*.server
 
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: obp-coredns
  strategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: obp-coredns
    spec:
      containers:
      - args:
        - -conf
        - /etc/coredns/Corefile
        image: docker.io/coredns/coredns:latest
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 5
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 5
        name: coredns
        ports:
        - containerPort: 1053
          name: dns
          protocol: UDP
        - containerPort: 1053
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /etc/coredns
          name: config-volume
          readOnly: true
        - mountPath: /etc/coredns/custom
          name: custom-config-volume
          readOnly: true
      dnsPolicy: Default
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      serviceAccount: obp-coredns
      serviceAccountName: obp-coredns
      terminationGracePeriodSeconds: 30
      volumes:
      - configMap:
          defaultMode: 420
          items:
          - key: Corefile
            path: Corefile
          name: coredns
        name: config-volume
      - configMap:
          defaultMode: 420
          name: coredns-custom
          optional: true
        name: custom-config-volume
 
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  ports:
  - name: dns
    port: 53
    protocol: UDP
    targetPort: 1053
  - name: dns-tcp
    port: 53
    protocol: TCP
    targetPort: 1053
  - name: metrics
    port: 9153
    protocol: TCP
    targetPort: 9153
  selector:
    app: obp-coredns
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: obp-coredns
  namespace: obp-coredns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: obp-coredns
rules:
- apiGroups:
  - ""
  resources:
  - endpoints
  - services
  - pods
  - namespaces
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - discovery.k8s.io
  resources:
  - endpointslices
  verbs:
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: obp-coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: obp-coredns
subjects:
- kind: ServiceAccount
  name: obp-coredns
  namespace: obp-coredns
  3. Créez un fichier coredns-custom-configmap au format YAML pour votre instance de chaîne de blocs.
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    <instanceName>.<domain>:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.<instanceName>\.<domain>\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
    Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine transmis lors de la création de l'instance.
  4. Exécutez la commande suivante pour appliquer l'objet ConfigMap personnalisé.
    kubectl apply -f <coredns-custom-configmap-yaml-file>
  5. Exécutez la commande suivante pour obtenir l'adresse IP de la grappe. Enregistrez l'adresse IP.
    kubectl get svc -n obp-coredns
  6. Exécutez la commande suivante pour modifier la ressource personnalisée DNS OpenShift.
    kubectl edit dnses.operator/default
  7. Mettez à jour la section Zones de la ressource personnalisée DNS pour utiliser votre instance et vos noms de domaine, comme illustré dans l'exemple suivant.
    ## Add the following section to the dns custom resource under spec
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - <instanceName>.<domain>
    Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.
  8. Pour ajouter de nouvelles instances, ajoutez des entrées au fichier coredns-custom-configmap et mettez à jour la ressource personnalisée DNS OpenShift pour le domaine de la nouvelle instance, comme illustré dans l'exemple suivant :
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    myobp.example.com:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.myobp\.example\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
 
    otherobp.example.org:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.otherobp\.example\.org istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }



## Edit the Openshift's DNS custom resource
kubectl edit dnses.operator/default
 
## Add the new instance domain to the existing .spec.servers.zones
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - myobp.example.com
    - otherobp.example.org
    Vous devez arrêter et redémarrer l'instance Blockchain Platform à l'aide de Blockchain Platform Manager pour que les modifications DNS prennent effet.

Configurer le DNS

Après avoir créé une instance Oracle Blockchain Platform Enterprise Edition, vous devez configurer un DNS afin que les noms d'hôte publics des composants puissent être résolus à partir du réseau local OpenShift.

Après avoir créé une instance, le nom de l'instance et le domaine parent sont utilisés en tant que sous-domaine pour les composants Oracle Blockchain Platform Enterprise Edition. Vous devez configurer le transfert DNS sur la configuration DNS par défaut pour OpenShift, de sorte que les demandes DNS soient transmises au module de réseautage DNS personnalisé où les services exposés sont résolus. Effectuez les étapes suivantes pour configurer le transfert DNS.
  1. Exécutez la commande suivante .
    oc new-project obp-coredns
  2. Déployez un serveur coredns personnalisé dans l'espace de noms obp-coredns en exécutant la commande suivante.
    kubectl apply -f <coredns-deployment-yaml-file>
    Utilisez le fichier manifeste suivant avec la commande.
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: obp-coredns
data:
  Corefile: |-
    .:1053 {
      errors
      health {
        lameduck 5s
      }
      ready
      kubernetes cluster.local in-addr.arpa ip6.arpa {
        pods insecure
        fallthrough in-addr.arpa ip6.arpa
      }
      prometheus :9153
      forward . /etc/resolv.conf
      cache 30
      loop
      reload
      loadbalance
    }
    import custom/*.server
 
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: obp-coredns
  strategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: obp-coredns
    spec:
      containers:
      - args:
        - -conf
        - /etc/coredns/Corefile
        image: docker.io/coredns/coredns:latest
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 5
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 5
        name: coredns
        ports:
        - containerPort: 1053
          name: dns
          protocol: UDP
        - containerPort: 1053
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /etc/coredns
          name: config-volume
          readOnly: true
        - mountPath: /etc/coredns/custom
          name: custom-config-volume
          readOnly: true
      dnsPolicy: Default
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      serviceAccount: obp-coredns
      serviceAccountName: obp-coredns
      terminationGracePeriodSeconds: 30
      volumes:
      - configMap:
          defaultMode: 420
          items:
          - key: Corefile
            path: Corefile
          name: coredns
        name: config-volume
      - configMap:
          defaultMode: 420
          name: coredns-custom
          optional: true
        name: custom-config-volume
 
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  ports:
  - name: dns
    port: 53
    protocol: UDP
    targetPort: 1053
  - name: dns-tcp
    port: 53
    protocol: TCP
    targetPort: 1053  
  - name: metrics
    port: 9153
    protocol: TCP
    targetPort: 9153
  selector:
    app: obp-coredns
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: obp-coredns
  namespace: obp-coredns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: obp-coredns
rules:
- apiGroups:
  - ""
  resources:
  - endpoints
  - services
  - pods
  - namespaces
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - discovery.k8s.io
  resources:
  - endpointslices
  verbs:
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: obp-coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: obp-coredns
subjects:
- kind: ServiceAccount
  name: obp-coredns
  namespace: obp-coredns
  3. Créez un fichier coredns-custom-configmap au format YAML pour votre instance de chaîne de blocs.
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    <instanceName>.<domain>:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.<instanceName>\.<domain>\ istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
    Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.
  4. Exécutez la commande suivante pour appliquer l'objet ConfigMap personnalisé.
    kubectl apply -f <coredns-custom-configmap-yaml-file>
  5. Exécutez la commande suivante pour obtenir l'adresse IP de la grappe. Enregistrez l'adresse IP.
    kubectl get svc -n obp-coredns
  6. Exécutez la commande suivante pour modifier la ressource personnalisée DNS OpenShift.
    kubectl edit dnses.operator/default
  7. Mettez à jour la section Zones de la ressource personnalisée DNS pour utiliser votre instance et vos noms de domaine, comme illustré dans l'exemple suivant.
    ## Add the following section to the dns custom resource under spec
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - <instanceName>.<domain>
    Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.
  8. Pour ajouter de nouvelles instances, ajoutez des entrées au fichier coredns-custom-configmap et mettez à jour la ressource personnalisée DNS OpenShift pour le domaine de la nouvelle instance, comme illustré dans l'exemple suivant.
    apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    myobp.example.com:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.myobp\.example\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
 
    otherobp.example.org:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.otherobp\.example\.org istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }



## Edit the Openshift's DNS custom resource
kubectl edit dnses.operator/default
 
## Add the new instance domain to the existing .spec.servers.zones
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - myobp.example.com
    - otherobp.example.org
    Vous devez arrêter et redémarrer l'instance pour que les modifications DNS prennent effet.
Avant d'accéder à la console de service Oracle Blockchain Platform, configurez la résolution du nom d'hôte pour les services d'instance de chaîne de blocs, comme vous l'avez fait précédemment pour les noms d'hôte Blockchain Platform Manager. Utilisez la commande suivante pour obtenir la liste des noms d'hôte de l'instance de chaîne de blocs créée :
kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]

Ajouter des noeuds supplémentaires à la grappe

Il est possible que la création de l'instance échoue en raison de noeuds insuffisants dans la grappe. Si cela se produit, vous devrez peut-être ajouter d'autres noeuds au cluster.
  1. Exécutez la commande suivante pour rechercher les pods à l'état En attente :
    kubectl get pods -n <instancename> | grep Pending
    De plus, vous pouvez vérifier qu'aucun pod n'est disponible :
    kubectl get pods -n instancename
  2. Vérifiez ensuite les noeuds de travail disponibles :
    kubectl get nodes | grep worker
  3. Pour vérifier s'il existe des noeuds disponibles pour prendre de nouveaux pods, exécutez la commande suivante sur chaque noeud de travail :
    kubectl describe node $<worker_node>
    où <worker_node> est le nom d'un noeud de travail. Assurez-vous que la capacité du noeud de travail ne dépasse pas 100 %.
  4. Pour ajouter des noeuds supplémentaires, obtenez d'abord le nombre de MachineSets dans la grappe :
    oc get machinesets -n openshift-machine-api
  5. Pour toute MachineSets avec moins de 2 noeuds, essayez de les mettre à l'échelle.
    oc scale --replicas=2 machineset <obpee00-qtthx-worker-eastus2> -n openshift-machine-api
    où <obpee00-qtthx-worker-eastus2> est un exemple de nom d'un MachineSet que vous voulez mettre à l'échelle à 2 noeuds.
  6. Interrogez de nouveau MachineSets jusqu'à ce que la liste des noeuds prêts et disponibles atteigne le nombre de noeuds que vous avez sélectionnés.
  7. Vous pouvez maintenant redéployer vos instances en échec.

Une fois votre instance créée et listée dans la liste Instances, vous pouvez lancer la console de service à partir du menu à côté du nom de l'instance. Utilisez la console pour configurer votre réseau, comme décrit dans À quoi sert la console? dans Utilisation d'Oracle Blockchain Platform.