<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="(C) Copyright 2005" />
<meta name="DC.rights.owner" content="(C) Copyright 2005" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="task" name="DC.Type" />
<meta name="DC.Title" content="Registering with a UDDI registry" />
<meta name="abstract" content="In order to publish your business entity and Web service to a UDDI registry, you must first register with the registry that you want to use." />
<meta name="description" content="In order to publish your business entity and Web service to a UDDI registry, you must first register with the registry that you want to use." />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.doc.user/concepts/cwsinwsa.html" />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.doc.user/concepts/cws.html" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cuddi.html" />
<meta scheme="URI" name="DC.Relation" content="tuddiexp.html" />
<meta scheme="URI" name="DC.Relation" content="tstrtexp.html" />
<meta scheme="URI" name="DC.Relation" content="../ref/ruddi.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="treg" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/commonltr.css" type="text/css" rel="stylesheet" />
<title>Registering with a UDDI Registry</title>
</head>
<body id="treg"><a name="treg"><!-- --></a>


<h1 class="topictitle1">Registering with a UDDI registry</h1>



<div><p>In order to publish your business entity and Web service to a UDDI
registry, you must first register with the registry that you want to use.</p>

<div class="section"><p>There are many different public and private registries with which
you can register.  For a list of public registries refer to  <a href="http://www.uddi.org/register.html" target="_blank">www.uddi.org/register.html</a> Since each registry is
different, the registry provider will give you instructions for registering.</p>
<p>The
following registries are automatically added to Favorites:</p>
<ul>
<li>IBM<sup>®</sup> UDDI
Registry</li>

<li>IBM UDDI
Test Registry</li>

<li>Microsoft<sup>®</sup> UDDI
Registry</li>

<li>Microsoft UDDI
Test Registry</li>

<li>SAP UDDI Registry</li>

<li>SAP UDDI Test Registry</li>

<li>XMethods Registry</li>

<li>NTT Communications Registry</li>

</ul>
<p>You can use any of these registries by selecting the Favorites icon
in the Web Services Explorer toolbar. All of these registries are based on
the UDDI Business Registry Version 2. Go to the following URL to obtain a
user ID and password for the IBM UDDI registry:  <a href="http://www-3.ibm.com/services/uddi/" target="_blank">www.ibm.com/services/uddi/</a>. The details page of each
registry will have registration instructions.</p>
<p>The IBM UDDI Test
Registry allows you to develop your Web service and experience the UDDI registration
process without placing your Web service in an official registry. Use the IBM UDDI
Test Registry or a private registry to experiment with UDDI, and to test and
validate your Web service. The public production registries are listed
under Favorites. The Web Services Explorer does not preload any registries
by default.  You can preload registries from the favorites section of
the Web Services Explorer or by using the Unit Test UDDI wizard. You can also
preload and configure private registries using the Unit Test UDDI wizard.
On the Open Registry page of the Web Services Explorer, you can select from
public registries and registries listed in your favorites to automatically
fill in the information required to open a particular registry.</p>
</div>

</div>

<div>
<div class="linklist"><strong>Related Concepts</strong><br />

<div><a href="../../org.eclipse.jst.ws.doc.user/concepts/cwsinwsa.html"> Tools for Web services development</a></div>
<div><a href="../../org.eclipse.jst.ws.doc.user/concepts/cws.html">Web services development</a></div>
<div><a href="../concepts/cuddi.html" title="Universal Description, Discovery, and Integration (UDDI) specification defines a way to publish and discover information about Web services.">Universal Description, Discovery, and Integration (UDDI)</a></div></div>

<div class="linklist"><strong>Related Tasks</strong><br />

<div><a href="tuddiexp.html" title="Through UDDI and WSIL, other applications can discover WSDL documents and bind with them to execute transactions or perform other business processes.">Publishing Web services and business entities</a></div>
<div><a href="tstrtexp.html" title="The Web services tools allows you to launch the Web Services Explorer in several ways.">Launching the Web Services Explorer</a></div></div>

<div class="linklist"><strong>Related Reference</strong><br />

<div><a href="../ref/ruddi.html" title="Once you have registered and logged in to the UDDI registry that you want to use, you can register your Web service.  Registration of a service involves four core data structure types: business information, service information, binding information, and information describing the specifications for services. The relationship between these data types is described in Figure 1.">Data structure types (UDDI registry)</a></div></div>
</div>

</body>
</html>