.endMetadata() .withNewSpec() .withSelector(serviceSelector) .withPorts(new ServicePortBuilder().withPort(port).withName("http").build(), new ServicePortBuilder().withPort(monitoringSettings.getPort()).withName("monitoring").build()) .endSpec();
.endMetadata() .editOrNewSpec() .addNewPort() .withName("https") .withPort(443) .withTargetPort(new IntOrString("https")) .endPort() .addToSelector("component", "api-server") .withType("LoadBalancer") .endSpec() .done();
serviceSpecBuilder.withPorts(servicePorts); serviceSpecBuilder.withClusterIP("None"); serviceSpecBuilder.withType(service.getType()); serviceSpecBuilder.endSpec();
.endMetadata() .withNewSpec() .withSelector(serviceSelector) .withPorts(new ServicePortBuilder().withPort(port).withName("http").build(), new ServicePortBuilder().withPort(monitoringSettings.getPort()).withName("monitoring").build()) .endSpec();
.endMetadata() .withNewSpec() .addToSelector("name", NAME) .withReplicas(1) .withNewTemplate() .withName("letschat-mongodb") .withImage("mongo") .addNewPort() .withContainerPort(27017) .withProtocol("TCP") .addNewEnv().withName("LCB_DATABASE_URI").withValue("mongodb://127.0.0.1:27017/letschat").endEnv() .endContainer() .endSpec() .endTemplate() .endSpec() .endMetadata() .withNewSpec() .withType("LoadBalancer") .addNewPort() .withPort(80)
.withNewMetadata().withName(serviceName).endMetadata() .withNewSpec() .addToSelector("app", "drools") .addNewPort().withPort(80).withNewTargetPort().withIntVal(8080).endTargetPort().endPort() .endSpec() .done();
.endMetadata() .editOrNewSpec() .withPorts(servicePorts) .withSelector(service.getSpec().getSelector()) .withLoadBalancerSourceRanges(exposeSpec.getLoadBalancerSourceRanges() != null ? exposeSpec.getLoadBalancerSourceRanges() : Collections.emptyList()) .withType("LoadBalancer") .endSpec();
.endMetadata() .withNewSpec() .addNewPort() .withProtocol(KubernetesConstants.KUBERNETES_SVC_PROTOCOL) .withPort(serviceModel.getPort()) .withNewTargetPort(serviceModel.getTargetPort()) .endPort() .addToSelector(KubernetesConstants.KUBERNETES_SELECTOR_KEY, serviceModel.getSelector()) .withSessionAffinity(serviceModel.getSessionAffinity()) .withType(serviceModel.getServiceType()) .endSpec() .build(); try {
private Service getDefaultService() { // No image config, no service if (!hasImageConfiguration()) { return null; } String serviceName = getConfig(Config.name, MavenUtil.createDefaultResourceName(getContext().getGav().getSanitizedArtifactId())); // Create service only for all images which are supposed to live in a single pod List<ServicePort> ports = extractPorts(getImages().get()); ServiceBuilder builder = new ServiceBuilder() .withNewMetadata() .withName(serviceName) .withLabels(extractLabels()) .endMetadata(); ServiceFluent.SpecNested<ServiceBuilder> specBuilder = builder.withNewSpec(); if (!ports.isEmpty()) { specBuilder.withPorts(ports); } else if (Configs.asBoolean(getConfig(Config.headless))) { specBuilder.withClusterIP("None"); } else { // No ports, no headless --> no service return null; } if (hasConfig(Config.type)) { specBuilder.withType(getConfig(Config.type)); } specBuilder.endSpec(); return builder.build(); }
private Service getDefaultService() { // No image config, no service if (!hasImageConfiguration()) { return null; } // Create service only for all images which are supposed to live in a single pod List<ServicePort> ports = extractPorts(getImages()); ServiceBuilder builder = new ServiceBuilder() .withNewMetadata() .withName(getConfig(Config.name, MavenUtil.createDefaultResourceName(getProject()))) .withLabels(extractLabels()) .endMetadata(); ServiceFluent.SpecNested<ServiceBuilder> specBuilder = builder.withNewSpec(); if (!ports.isEmpty()) { specBuilder.withPorts(ports); } else if (Configs.asBoolean(getConfig(Config.headless))) { specBuilder.withClusterIP("None"); } else { // No ports, no headless --> no service return null; } if (hasConfig(Config.type)) { specBuilder.withType(getConfig(Config.type)); } specBuilder.endSpec(); return builder.build(); }
private void ensureService(String name, DeploymentData deploymentData) { final Map<String, String> labels = prepareServiceLabels(deploymentData); final Map<String, String> annotations = prepareServiceAnnotations(deploymentData); openShiftClient.services().withName(name).createOrReplaceWithNew() .withNewMetadata() .withName(name) .addToAnnotations(annotations) .addToLabels(labels) .endMetadata() .withNewSpec() .addToSelector(INTEGRATION_NAME_LABEL, name) .addNewPort() .withName("http") .withProtocol("TCP") .withPort(INTEGRATION_SERVICE_PORT) .withNewTargetPort(INTEGRATION_SERVICE_PORT) .endPort() .endSpec() .done(); }
public void onTemplate(TemplateBuilder builder) { builder.addNewServiceObject() .withNewMetadata() .withName("elasticsearch-cluster") .endMetadata() .withNewSpec() .withClusterIP("None") .addNewPort() .withName("") .withProtocol("TCP") .withPort(9300) .withNewTargetPort(9300) .endPort() .addToSelector("component", "elasticsearch") .addToSelector("provider", "fabric8") .endSpec() .and() .build(); }
private static Service getMessagingClientServiceResource() { return new ServiceBuilder() .withNewMetadata() .withName(SystemtestsOpenshiftApp.MESSAGING_CLIENTS.toString()) .addToLabels("run", SystemtestsOpenshiftApp.MESSAGING_CLIENTS.toString()) .endMetadata() .withNewSpec() .withSelector(Collections.singletonMap("app", SystemtestsOpenshiftApp.MESSAGING_CLIENTS.toString())) .addNewPort() .withName("http") .withPort(4242) .withProtocol("TCP") .endPort() .endSpec() .build(); } }
protected Service exposeService(String namespace, Map<String, String> metadata, String serviceName, Iterable<Integer> inboundPorts) { List<ServicePort> servicePorts = Lists.newArrayList(); for (Integer inboundPort : inboundPorts) { servicePorts.add(new ServicePortBuilder().withName(Integer.toString(inboundPort)).withPort(inboundPort).build()); } Service service = new ServiceBuilder().withNewMetadata().withName(serviceName).endMetadata() .withNewSpec() .addToSelector(metadata) .addToPorts(Iterables.toArray(servicePorts, ServicePort.class)) .withType(NODE_PORT) .endSpec() .build(); client.services().inNamespace(namespace).create(service); service = getService(namespace, serviceName); LOG.debug("Exposed service {} in namespace {}.", service, namespace); return service; }
protected Service createHeadlessService(List<ServicePort> ports, Map<String, String> annotations) { Service service = new ServiceBuilder() .withNewMetadata() .withName(headlessServiceName) .withLabels(getLabelsWithName(headlessServiceName, templateHeadlessServiceLabels)) .withNamespace(namespace) .withAnnotations(mergeAnnotations(annotations, templateHeadlessServiceAnnotations)) .withOwnerReferences(createOwnerReference()) .endMetadata() .withNewSpec() .withType("ClusterIP") .withClusterIP("None") .withSelector(getSelectorLabels()) .withPorts(ports) .endSpec() .build(); log.trace("Created headless service {}", service); return service; }
protected Service createService(String name, String type, List<ServicePort> ports, Map<String, String> labels, Map<String, String> selector, Map<String, String> annotations) { Service service = new ServiceBuilder() .withNewMetadata() .withName(name) .withLabels(labels) .withNamespace(namespace) .withAnnotations(annotations) .withOwnerReferences(createOwnerReference()) .endMetadata() .withNewSpec() .withType(type) .withSelector(selector) .withPorts(ports) .endSpec() .build(); log.trace("Created service {}", service); return service; }
private void addMissingServiceParts(ServiceBuilder service, Service defaultService) { // If service has no spec -> take over the complete spec from default service if (!service.hasSpec()) { service.withNewSpecLike(defaultService.getSpec()).endSpec(); return; } // If service has no ports -> take over ports from default service List<ServicePort> ports = service.buildSpec().getPorts(); if (ports == null || ports.isEmpty()) { service.editSpec().withPorts(defaultService.getSpec().getPorts()).endSpec(); return; } // Complete missing parts: service.editSpec() .withPorts(addMissingDefaultPorts(ports, defaultService)) .endSpec(); }
private void addMissingServiceParts(ServiceBuilder service, Service defaultService) { // If service has no spec -> take over the complete spec from default service if (!service.hasSpec()) { service.withNewSpecLike(defaultService.getSpec()).endSpec(); return; } // If service has no ports -> take over ports from default service List<ServicePort> ports = service.buildSpec().getPorts(); if (ports == null || ports.isEmpty()) { service.editSpec().withPorts(defaultService.getSpec().getPorts()).endSpec(); return; } // Complete missing parts: service.editSpec() .withPorts(addMissingDefaultPorts(ports, defaultService)) .endSpec(); }
@Override public Service patch(Service item) { try { Service old = getMandatory(); return super.patch(new ServiceBuilder(item) .editSpec() .withClusterIP(old.getSpec().getClusterIP()) .endSpec() .build()); } catch (Exception e) { throw KubernetesClientException.launderThrowable(e); } }